Add new implicit arg for OpenCL inline sampler in bindless mode

To support OpenCL inline sampler in bindless mode, a new implicit arg
`inlineSampler` is added for each unique inline sampler. The arg passes
bindless offset of its sampler state into the kernel.
Therefore, a new zeinfo payload argument `inline_sampler` is added for
the implicit arg. The payload argument has an entry `sampler_index`
that is used for looking up inline sampler entry in `inline_samplers`
section of zeinfo. For example,
    payload_arguments:
      - arg_type:        inline_sampler
        offset:          60
        size:            4
        addrmode:        bindless
        addrspace:       sampler
        sampler_index:   1
    inline_samplers:
      - sampler_index:   1
        addrmode:        none
        filtermode:      nearest

Author: wenju-he

IGC/AdaptorCommon/AddImplicitArgs.hpp

@@ -53,7 +53,7 @@ namespace IGC
         /// @brief  Provides name of pass
         virtual llvm::StringRef getPassName() const override
         {
-            return "AddImplictArgs";
+            return "AddImplicitArgs";
         }
 
         virtual void getAnalysisUsage(llvm::AnalysisUsage &AU) const override

IGC/AdaptorCommon/ImplicitArgs.cpp

@@ -62,6 +62,7 @@ static const std::vector<ImplicitArg> IMPLICIT_ARGS = {
     ImplicitArg(ImplicitArg::SAMPLER_ADDRESS, "smpAddress", ImplicitArg::INT, WIAnalysis::UNIFORM_GLOBAL, 1, ImplicitArg::ALIGN_DWORD, true),
     ImplicitArg(ImplicitArg::SAMPLER_NORMALIZED, "smpNormalized", ImplicitArg::INT, WIAnalysis::UNIFORM_GLOBAL, 1, ImplicitArg::ALIGN_DWORD, true),
     ImplicitArg(ImplicitArg::SAMPLER_SNAP_WA, "smpSnapWA", ImplicitArg::INT, WIAnalysis::UNIFORM_GLOBAL, 1, ImplicitArg::ALIGN_DWORD, true),
+    ImplicitArg(ImplicitArg::INLINE_SAMPLER, "inlineSampler", ImplicitArg::INT, WIAnalysis::UNIFORM_GLOBAL, 1, ImplicitArg::ALIGN_DWORD, true),
     ImplicitArg(ImplicitArg::FLAT_IMAGE_BASEOFFSET, "flatImageBaseoffset", ImplicitArg::LONG, WIAnalysis::UNIFORM_GLOBAL, 1, ImplicitArg::ALIGN_QWORD, true),
     ImplicitArg(ImplicitArg::FLAT_IMAGE_HEIGHT, "flatImageHeight", ImplicitArg::INT, WIAnalysis::UNIFORM_GLOBAL, 1, ImplicitArg::ALIGN_DWORD, true),
     ImplicitArg(ImplicitArg::FLAT_IMAGE_WIDTH, "flatImageWidth", ImplicitArg::INT, WIAnalysis::UNIFORM_GLOBAL, 1, ImplicitArg::ALIGN_DWORD, true),
@@ -648,6 +649,27 @@ bool ImplicitArgs::isImplicitStruct(ImplicitArg::ArgType argType)
     return (argType >= ImplicitArg::STRUCT_START) && (argType <= ImplicitArg::STRUCT_END);
 }
 
+bool ImplicitArgs::isImplicitArg(Argument *arg) const
+{
+    unsigned argSize = arg->getParent()->arg_size();
+    unsigned numImplicitArgs = size();
+    IGC_ASSERT_MESSAGE(argSize >= numImplicitArgs, "Function arg size does not match meta data args.");
+    unsigned argNo = arg->getArgNo();
+    return argNo >= (argSize - numImplicitArgs);
+}
+
+int ImplicitArgs::getExplicitArgNumForArg(Argument *implicitArg) const
+{
+    unsigned argSize = implicitArg->getParent()->arg_size();
+    unsigned numImplicitArgs = size();
+    IGC_ASSERT_MESSAGE(argSize >= numImplicitArgs, "Function arg size does not match meta data args.");
+    unsigned argNo = implicitArg->getArgNo();
+    IGC_ASSERT_MESSAGE(argNo >= (argSize - numImplicitArgs), "The arg should be implicit arg");
+    unsigned implicitArgIndex = argNo - (argSize - numImplicitArgs);
+    ArgInfoMetaDataHandle argInfo = m_funcInfoMD->getImplicitArgInfoListItem(implicitArgIndex);
+    return argInfo->getExplicitArgNum();
+}
+
 ImplicitArg::ArgType ImplicitArgs::getArgType(unsigned int index) const {
     IGC_ASSERT_MESSAGE((index < size()), "Index out of range");
     ArgInfoMetaDataHandle argInfo = m_funcInfoMD->getImplicitArgInfoListItem(index);

IGC/AdaptorCommon/ImplicitArgs.hpp

@@ -81,6 +81,7 @@ namespace IGC
             SAMPLER_ADDRESS,
             SAMPLER_NORMALIZED,
             SAMPLER_SNAP_WA,
+            INLINE_SAMPLER,
             FLAT_IMAGE_BASEOFFSET,
             FLAT_IMAGE_HEIGHT,
             FLAT_IMAGE_WIDTH,
@@ -362,6 +363,14 @@ namespace IGC
         /// @param  argType The argument type to check.
         static bool isImplicitStruct(ImplicitArg::ArgType argType);
 
+        /// @brief  Returns true if the given argument is an implicit argument.
+        /// @param  arg The argument to check.
+        bool isImplicitArg(llvm::Argument *arg) const;
+
+        /// @brief  Returns explicit argument number associated with the given implicit argument.
+        /// @param  implicitArg The associated implicit argument.
+        int getExplicitArgNumForArg(llvm::Argument *implicitArg) const;
+
         llvm::Value* getImplicitArgValue(llvm::Function& F, ImplicitArg::ArgType argType, const IGCMD::MetaDataUtils* pMdUtils);
 
     private:

IGC/Compiler/CISACodeGen/OpenCLKernelCodeGen.cpp

@@ -1307,6 +1307,19 @@ namespace IGC
             break;
         }
 
+        case KernelArg::ArgType::IMPLICIT_INLINE_SAMPLER: {
+            uint32_t arg_idx = kernelArg->getAssociatedArgNo();
+            ResourceAllocMD& resAllocMD = GetContext()->getModuleMetaData()->FuncMD[entry].resAllocMD;
+            auto it = llvm::find_if(resAllocMD.inlineSamplersMD, [&](auto &inlineSamplerMD) {
+              return inlineSamplerMD.m_Value == arg_idx;
+            });
+            IGC_ASSERT_MESSAGE(it != resAllocMD.inlineSamplersMD.end(), "Inline sampler isn't found in metadata.");
+            zebin::ZEInfoBuilder::addPayloadArgumentImplicitInlineSampler(
+                        m_kernelInfo.m_zePayloadArgs, zebin::PreDefinedAttrGetter::ArgType::inline_sampler, payloadPosition,
+                        kernelArg->getAllocateSize(), it->index);
+            break;
+        }
+
         case KernelArg::ArgType::IMPLICIT_BUFFER_OFFSET: {
             zebin::zeInfoPayloadArgument& arg = zebin::ZEInfoBuilder::addPayloadArgumentImplicit(m_kernelInfo.m_zePayloadArgs,
                 zebin::PreDefinedAttrGetter::ArgType::buffer_offset,

IGC/Compiler/Optimizer/OCLBIUtils.cpp

@@ -15,9 +15,11 @@ SPDX-License-Identifier: MIT
 #include "llvmWrapper/IR/IRBuilder.h"
 #include "llvmWrapper/IR/Instructions.h"
 #include "common/LLVMWarningsPop.hpp"
+#include "AdaptorCommon/ImplicitArgs.hpp"
 #include "LLVM3DBuilder/BuiltinsFrontend.hpp"
 #include "Probe/Assertion.h"
 #include "IGC/common/StringMacros.hpp"
+#include <llvm/Support/Casting.h>
 
 using namespace llvm;
 using namespace IGC;
@@ -249,7 +251,7 @@ Argument* CImagesBI::CImagesUtils::findImageFromBufferPtr(const MetaDataUtils& M
     return nullptr;
 }
 
-static bool isBindlessImageLoad(Value *v)
+static bool isSYCLBindlessImageLoad(Value *v)
 {
     auto *load = dyn_cast<LoadInst>(v);
     if (!load)
@@ -270,7 +272,7 @@ ConstantInt* CImagesBI::CImagesUtils::getImageIndex(
 {
     ConstantInt* imageIndex = nullptr;
 
-    imageParam = ValueTracker::track(pCallInst, paramIndex, nullptr, nullptr, isBindlessImageLoad);
+    imageParam = ValueTracker::track(pCallInst, paramIndex, nullptr, nullptr, isSYCLBindlessImageLoad);
     IGC_ASSERT(imageParam);
     IGC_ASSERT(isa<Argument>(imageParam) || isa<LoadInst>(imageParam));
     int i = (*pParamMap)[imageParam].index;
@@ -280,7 +282,7 @@ ConstantInt* CImagesBI::CImagesUtils::getImageIndex(
 
 BufferType CImagesBI::CImagesUtils::getImageType(ParamMap* pParamMap, CallInst* pCallInst, unsigned int paramIndex)
 {
-    Value *imageParam = ValueTracker::track(pCallInst, paramIndex, nullptr, nullptr, isBindlessImageLoad);
+    Value *imageParam = ValueTracker::track(pCallInst, paramIndex, nullptr, nullptr, isSYCLBindlessImageLoad);
     IGC_ASSERT(imageParam);
     IGC_ASSERT(isa<Argument>(imageParam) || isa<LoadInst>(imageParam));
     return isa<LoadInst>(imageParam) ? BufferType::BINDLESS : (*pParamMap)[imageParam].type;
@@ -439,62 +441,104 @@ class COCL_sample : public CImagesBI
             }
             return false;
         };
-        Value* samplerParam = ValueTracker::track(m_pCallInst, 1, m_pMdUtils, m_modMD, isBindlessSampler);
-        if (!samplerParam) {
+        Value* samplerValue = ValueTracker::track(m_pCallInst, 1, m_pMdUtils, m_modMD, isBindlessSampler);
+        if (!samplerValue) {
             emitError("There are instructions that use a sampler, but no sampler found in the kernel!", m_pCallInst);
             return nullptr;
         }
 
         auto modMD = m_pCodeGenContext->getModuleMetaData();
 
-        // If bindless image is preferred, map the bindless pointer
+        auto addToInlineSamplersMD = [&](int samplerConstantVal)
+        {
+            // Is this sampler already allocated?
+            auto iter = m_pInlineMap->find(samplerConstantVal);
+            if (iter != m_pInlineMap->end())
+            {
+                return ConstantInt::get(m_pIntType, iter->second);
+            }
+
+            // No, allocate it.
+            int currSamplerIdx = (*m_pNextSampler)++;
+            (*m_pInlineMap)[samplerConstantVal] = currSamplerIdx;
+            samplerIndex = ConstantInt::get(m_pIntType, currSamplerIdx);
+
+            // Push this information into the metadata, for the state processor's benefit
+            FunctionMetaData& funcMD = m_modMD->FuncMD[m_pFunc];
+            ResourceAllocMD& resAllocMD = funcMD.resAllocMD;
+            InlineSamplersMD inlineSamplerMD;
+            CreateInlineSamplerAnnotations(inlineSamplerMD, samplerConstantVal);
+            inlineSamplerMD.index = currSamplerIdx;
+            resAllocMD.inlineSamplersMD.push_back(inlineSamplerMD);
+            m_pMdUtils->save(*m_pCtx);
+            return samplerIndex;
+        };
+
         if (modMD->UseBindlessImage)
         {
-            // If sampler is argument, look up index in the parameter map.
-            int i = isa<Argument>(samplerParam) ? (*m_pParamMap)[samplerParam].index : 0;
-            samplerIndex = ConstantInt::get(m_pIntType, i);
-            unsigned int addressSpace = IGC::EncodeAS4GFXResource(*samplerIndex, BufferType::BINDLESS_SAMPLER);
-            Type* ptrTy = llvm::PointerType::get(m_pFloatType, addressSpace);
-            Value* bindlessSampler = isa<IntegerType>(samplerParam->getType()) ?
-                BitCastInst::CreateBitOrPointerCast(samplerParam, ptrTy, "bindless_sampler", m_pCallInst) :
-                BitCastInst::CreatePointerCast(samplerParam, ptrTy, "bindless_sampler", m_pCallInst);
+            // In bindless mode, samplerValue is BinaryOperator::Or computed in ResolveSampledImageBuiltins pass.
+            // Continue to track back the sampler's origin value, which could be one of following values:
+            //   * a constant, e.g. inline sampler.
+            //   * kernel argument, e.g. sampler that is kernel argument.
+            //   * load inst, e.g. sampler in SYCL bindless sampled image.
+            Value *samplerValueOrigin = ValueTracker::track(samplerValue, m_pFunc, m_pMdUtils, m_modMD, isSYCLBindlessImageLoad);
+            if (!samplerValueOrigin) {
+                emitError("There are instructions that use a sampler, but no sampler found in the kernel!", m_pCallInst);
+                return nullptr;
+            }
+            // Map the bindless pointer.
+            Value *bindlessSampler = nullptr;
+            if (auto *samplerConstant = dyn_cast<ConstantInt>(samplerValueOrigin))
+            {
+                // Sampler is constant, e.g. inline sampler.
+                int samplerConstantVal = int_cast<int>(samplerConstant->getZExtValue());
+                samplerIndex = addToInlineSamplersMD(samplerConstantVal);
+
+                // Bindless inline sampler is passed via implicit kernel argument.
+                ImplicitArgs implicitArgs(*m_pFunc, m_pMdUtils);
+
+                Argument *arg = implicitArgs.getNumberedImplicitArg(*m_pFunc, ImplicitArg::INLINE_SAMPLER, samplerConstantVal);
+                if (!arg) {
+                    emitError("Implicit arg isn't found for inline sampler!", m_pCallInst);
+                    return nullptr;
+                }
+                auto *binOp = cast<BinaryOperator>(samplerValue);
+                auto *argExt = new ZExtInst(arg, Type::getInt64Ty(*m_pCtx), "", binOp);
+                binOp->setOperand(0, argExt);
+
+                unsigned addressSpace = IGC::EncodeAS4GFXResource(*samplerIndex, BufferType::BINDLESS_SAMPLER);
+                Type *ptrTy = PointerType::get(m_pFloatType, addressSpace);
+                bindlessSampler = BitCastInst::CreateBitOrPointerCast(m_pCallInst->getOperand(1), ptrTy, "bindless_sampler", m_pCallInst);
+            }
+            else
+            {
+                // Sampler is either sampler that is kernel argument, or sampler in SYCL bindless sampled image.
+                // If sampler is argument, look up index in the parameter map.
+                int i = isa<Argument>(samplerValueOrigin) ? (*m_pParamMap)[samplerValueOrigin].index : 0;
+                samplerIndex = ConstantInt::get(m_pIntType, i);
+                unsigned int addressSpace = IGC::EncodeAS4GFXResource(*samplerIndex, BufferType::BINDLESS_SAMPLER);
+                Type* ptrTy = llvm::PointerType::get(m_pFloatType, addressSpace);
+                bindlessSampler = isa<IntegerType>(samplerValue->getType()) ?
+                    BitCastInst::CreateBitOrPointerCast(samplerValue, ptrTy, "bindless_sampler", m_pCallInst) :
+                    BitCastInst::CreatePointerCast(samplerValue, ptrTy, "bindless_sampler", m_pCallInst);
+            }
             return bindlessSampler;
         }
 
         // Argument samplers are looked up in the parameter map
-        if (isa<Argument>(samplerParam))
+        if (isa<Argument>(samplerValue))
         {
-            int i = (*m_pParamMap)[samplerParam].index;
+            int i = (*m_pParamMap)[samplerValue].index;
             samplerIndex = ConstantInt::get(m_pIntType, i);
             return samplerIndex;
         }
 
         // The sampler is not an argument, make sure it's a constant
-        IGC_ASSERT_MESSAGE(isa<ConstantInt>(samplerParam), "Sampler must be a global variable or a constant");
-        ConstantInt* constSampler = cast<ConstantInt>(samplerParam);
-        int samplerValue = int_cast<int>(constSampler->getZExtValue());
-
-        // Is this sampler already allocated?
-        auto iter = m_pInlineMap->find(samplerValue);
-        if (iter != m_pInlineMap->end())
-        {
-            return ConstantInt::get(m_pIntType, iter->second);
-        }
+        IGC_ASSERT_MESSAGE(isa<ConstantInt>(samplerValue), "Sampler must be a global variable or a constant");
+        auto *samplerConstant = cast<ConstantInt>(samplerValue);
+        int samplerConstantVal = int_cast<int>(samplerConstant->getZExtValue());
 
-        // No, allocate it.
-        int currSamplerIdx = (*m_pNextSampler)++;
-        (*m_pInlineMap)[samplerValue] = currSamplerIdx;
-        samplerIndex = ConstantInt::get(m_pIntType, currSamplerIdx);
-
-        // Push this information into the metadata, for the state processor's benefit
-        FunctionMetaData& funcMD = m_modMD->FuncMD[m_pFunc];
-        ResourceAllocMD& resAllocMD = funcMD.resAllocMD;
-        InlineSamplersMD inlineSamplerMD;
-        CreateInlineSamplerAnnotations(inlineSamplerMD, samplerValue);
-        inlineSamplerMD.index = currSamplerIdx;
-        resAllocMD.inlineSamplersMD.push_back(inlineSamplerMD);
-        m_pMdUtils->save(*m_pCtx);
-        return samplerIndex;
+        return addToInlineSamplersMD(samplerConstantVal);
     }
 
     void CreateInlineSamplerAnnotations(InlineSamplersMD& inlineSamplerMD, int samplerValue)

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

@@ -212,7 +212,9 @@ Value* ImageFuncResolution::getSamplerProperty(CallInst& CI)
     ModuleMetaData* modMD = getAnalysis<MetaDataUtilsWrapper>().getModuleMetaData();
     if (Value* sampler = ValueTracker::track(&CI, 0, pMdUtils, modMD))
     {
-        if (isa<Argument>(sampler))
+        auto *arg = dyn_cast<Argument>(sampler);
+        bool isImplicitInlineSamplerArg = arg ? m_implicitArgs.isImplicitArg(arg) : false;
+        if (arg && !isImplicitInlineSamplerArg)
         {
             if (m_implicitArgs.isImplicitArgExist(ArgTy))
             {
@@ -224,13 +226,22 @@ Value* ImageFuncResolution::getSamplerProperty(CallInst& CI)
         {
             llvm::Function* pFunc = CI.getFunction();
 
-            IGC_ASSERT_MESSAGE(isa<ConstantInt>(sampler), "Sampler must be a constant integer");
             uint64_t samplerVal = 0;
             if (modMD->FuncMD.find(pFunc) != modMD->FuncMD.end())
             {
                 FunctionMetaData funcMD = modMD->FuncMD[pFunc];
                 ResourceAllocMD resAllocMD = funcMD.resAllocMD;
-                uint samplerValue = int_cast<unsigned int>(cast<ConstantInt>(sampler)->getZExtValue());
+                unsigned samplerValue;
+                if (isImplicitInlineSamplerArg)
+                {
+                    // Inline sampler value is stored as explicit argument number in ImageFuncsAnalysis pass.
+                    samplerValue = m_implicitArgs.getExplicitArgNumForArg(arg);
+                }
+                else
+                {
+                    IGC_ASSERT_MESSAGE(isa<ConstantInt>(sampler), "Sampler must be a constant integer");
+                    samplerValue = int_cast<unsigned int>(cast<ConstantInt>(sampler)->getZExtValue());
+                }
                 for (auto i = resAllocMD.inlineSamplersMD.begin(), e = resAllocMD.inlineSamplersMD.end(); i != e; i++)
                 {
                     IGC::InlineSamplersMD inlineSamplerMD = *i;

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

@@ -56,8 +56,8 @@ bool ImageFuncsAnalysis::runOnModule(Module& M) {
     m_pMDUtils = getAnalysis<MetaDataUtilsWrapper>().getMetaDataUtils();
     CodeGenContext* ctx = getAnalysis<CodeGenContextWrapper>().getCodeGenContext();
 
-    m_addImplicitImageArgs = !ctx->getModuleMetaData()->compOpt.UseBindlessMode ||
-                                 ctx->getModuleMetaData()->compOpt.UseLegacyBindlessMode;
+    m_useAdvancedBindlessMode = ctx->getModuleMetaData()->compOpt.UseBindlessMode &&
+                                !ctx->getModuleMetaData()->compOpt.UseLegacyBindlessMode;
 
     // Run on all functions defined in this module
     for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
@@ -81,7 +81,7 @@ bool ImageFuncsAnalysis::runOnFunction(Function& F) {
     // Visit the function
     visit(F);
 
-    ImplicitArgs::addImageArgs(F, m_argMap, getAnalysis<MetaDataUtilsWrapper>().getMetaDataUtils());
+    ImplicitArgs::addImageArgs(F, m_argMap, m_pMDUtils);
 
     m_argMap.clear();
 
@@ -100,15 +100,15 @@ void ImageFuncsAnalysis::visitCallInst(CallInst& CI)
     // Check for OpenCL image dimension function calls
     std::set<int>* imageFunc = nullptr;
 
-    if (funcName == GET_IMAGE_HEIGHT && m_addImplicitImageArgs)
+    if (funcName == GET_IMAGE_HEIGHT && !m_useAdvancedBindlessMode)
     {
         imageFunc = &m_argMap[ImplicitArg::IMAGE_HEIGHT];
     }
-    else if (funcName == GET_IMAGE_WIDTH && m_addImplicitImageArgs)
+    else if (funcName == GET_IMAGE_WIDTH && !m_useAdvancedBindlessMode)
     {
         imageFunc = &m_argMap[ImplicitArg::IMAGE_WIDTH];
     }
-    else if (funcName == GET_IMAGE_DEPTH && m_addImplicitImageArgs)
+    else if (funcName == GET_IMAGE_DEPTH && !m_useAdvancedBindlessMode)
     {
         imageFunc = &m_argMap[ImplicitArg::IMAGE_DEPTH];
     }
@@ -128,7 +128,7 @@ void ImageFuncsAnalysis::visitCallInst(CallInst& CI)
     {
         imageFunc = &m_argMap[ImplicitArg::IMAGE_SRGB_CHANNEL_ORDER];
     }
-    else if ((funcName == GET_IMAGE1D_ARRAY_SIZE || funcName == GET_IMAGE2D_ARRAY_SIZE) && m_addImplicitImageArgs)
+    else if ((funcName == GET_IMAGE1D_ARRAY_SIZE || funcName == GET_IMAGE2D_ARRAY_SIZE) && !m_useAdvancedBindlessMode)
     {
         imageFunc = &m_argMap[ImplicitArg::IMAGE_ARRAY_SIZE];
     }
@@ -197,9 +197,21 @@ void ImageFuncsAnalysis::visitCallInst(CallInst& CI)
     // These WAs need to be reworked to support indirect case in the future.
     if (callArg)
     {
-        if (Argument * arg = dyn_cast<Argument>(callArg); arg && isSamplerArgument(arg))
+        if (Argument * arg = dyn_cast<Argument>(callArg))
         {
-            imageFunc->insert(arg->getArgNo());
+            if (isSamplerArgument(arg))
+            {
+                imageFunc->insert(arg->getArgNo());
+                return;
+            }
+        }
+        else if (m_useAdvancedBindlessMode)
+        {
+            IGC_ASSERT_MESSAGE(isa<ConstantInt>(callArg), "Expect inline sampler");
+            auto *inlineSampler = cast<ConstantInt>(callArg);
+            // Inline sampler doesn't associate with an explicit argument.
+            // To avoid adding a new metadata entry, inline sampler value is stored as explicit argument number.
+            m_argMap[ImplicitArg::INLINE_SAMPLER].insert(int_cast<int>(inlineSampler->getZExtValue()));
             return;
         }
     }

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

@@ -103,9 +103,10 @@ namespace IGC
         /// @brief  MetaData utils used to generate LLVM metadata
         IGCMD::MetaDataUtils* m_pMDUtils = nullptr;
 
-        /// @brief If true, implicit image args for information like width, height, etc.
+        /// @brief Indicate whether advanced bindless mode is used.
+        ///        If false, implicit image args for information like width, height, etc.
         ///        will be added to m_argMap
-        bool m_addImplicitImageArgs{};
+        bool m_useAdvancedBindlessMode{};
     };
 
 } // namespace IGC