[Autobackout][FunctionalRegression]Revert of change: 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: sys-igc

IGC/AdaptorCommon/AddImplicitArgs.hpp

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

IGC/AdaptorCommon/ImplicitArgs.cpp

@@ -62,7 +62,6 @@ 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),
@@ -649,27 +648,6 @@ 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,7 +81,6 @@ namespace IGC
             SAMPLER_ADDRESS,
             SAMPLER_NORMALIZED,
             SAMPLER_SNAP_WA,
-            INLINE_SAMPLER,
             FLAT_IMAGE_BASEOFFSET,
             FLAT_IMAGE_HEIGHT,
             FLAT_IMAGE_WIDTH,
@@ -363,14 +362,6 @@ 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,19 +1307,6 @@ 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,11 +15,9 @@ 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;
@@ -251,7 +249,7 @@ Argument* CImagesBI::CImagesUtils::findImageFromBufferPtr(const MetaDataUtils& M
     return nullptr;
 }
 
-static bool isSYCLBindlessImageLoad(Value *v)
+static bool isBindlessImageLoad(Value *v)
 {
     auto *load = dyn_cast<LoadInst>(v);
     if (!load)
@@ -272,7 +270,7 @@ ConstantInt* CImagesBI::CImagesUtils::getImageIndex(
 {
     ConstantInt* imageIndex = nullptr;
 
-    imageParam = ValueTracker::track(pCallInst, paramIndex, nullptr, nullptr, isSYCLBindlessImageLoad);
+    imageParam = ValueTracker::track(pCallInst, paramIndex, nullptr, nullptr, isBindlessImageLoad);
     IGC_ASSERT(imageParam);
     IGC_ASSERT(isa<Argument>(imageParam) || isa<LoadInst>(imageParam));
     int i = (*pParamMap)[imageParam].index;
@@ -282,7 +280,7 @@ ConstantInt* CImagesBI::CImagesUtils::getImageIndex(
 
 BufferType CImagesBI::CImagesUtils::getImageType(ParamMap* pParamMap, CallInst* pCallInst, unsigned int paramIndex)
 {
-    Value *imageParam = ValueTracker::track(pCallInst, paramIndex, nullptr, nullptr, isSYCLBindlessImageLoad);
+    Value *imageParam = ValueTracker::track(pCallInst, paramIndex, nullptr, nullptr, isBindlessImageLoad);
     IGC_ASSERT(imageParam);
     IGC_ASSERT(isa<Argument>(imageParam) || isa<LoadInst>(imageParam));
     return isa<LoadInst>(imageParam) ? BufferType::BINDLESS : (*pParamMap)[imageParam].type;
@@ -441,104 +439,62 @@ class COCL_sample : public CImagesBI
             }
             return false;
         };
-        Value* samplerValue = ValueTracker::track(m_pCallInst, 1, m_pMdUtils, m_modMD, isBindlessSampler);
-        if (!samplerValue) {
+        Value* samplerParam = ValueTracker::track(m_pCallInst, 1, m_pMdUtils, m_modMD, isBindlessSampler);
+        if (!samplerParam) {
             emitError("There are instructions that use a sampler, but no sampler found in the kernel!", m_pCallInst);
             return nullptr;
         }
 
         auto modMD = m_pCodeGenContext->getModuleMetaData();
 
-        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 bindless image is preferred, map the bindless pointer
         if (modMD->UseBindlessImage)
         {
-            // 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);
-            }
+            // 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);
             return bindlessSampler;
         }
 
         // Argument samplers are looked up in the parameter map
-        if (isa<Argument>(samplerValue))
+        if (isa<Argument>(samplerParam))
         {
-            int i = (*m_pParamMap)[samplerValue].index;
+            int i = (*m_pParamMap)[samplerParam].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>(samplerValue), "Sampler must be a global variable or a constant");
-        auto *samplerConstant = cast<ConstantInt>(samplerValue);
-        int samplerConstantVal = int_cast<int>(samplerConstant->getZExtValue());
+        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);
+        }
 
-        return addToInlineSamplersMD(samplerConstantVal);
+        // 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;
     }
 
     void CreateInlineSamplerAnnotations(InlineSamplersMD& inlineSamplerMD, int samplerValue)

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

@@ -212,9 +212,7 @@ Value* ImageFuncResolution::getSamplerProperty(CallInst& CI)
     ModuleMetaData* modMD = getAnalysis<MetaDataUtilsWrapper>().getModuleMetaData();
     if (Value* sampler = ValueTracker::track(&CI, 0, pMdUtils, modMD))
     {
-        auto *arg = dyn_cast<Argument>(sampler);
-        bool isImplicitInlineSamplerArg = arg ? m_implicitArgs.isImplicitArg(arg) : false;
-        if (arg && !isImplicitInlineSamplerArg)
+        if (isa<Argument>(sampler))
         {
             if (m_implicitArgs.isImplicitArgExist(ArgTy))
             {
@@ -226,22 +224,13 @@ 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;
-                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());
-                }
+                uint 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_useAdvancedBindlessMode = ctx->getModuleMetaData()->compOpt.UseBindlessMode &&
-                                !ctx->getModuleMetaData()->compOpt.UseLegacyBindlessMode;
+    m_addImplicitImageArgs = !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, m_pMDUtils);
+    ImplicitArgs::addImageArgs(F, m_argMap, getAnalysis<MetaDataUtilsWrapper>().getMetaDataUtils());
 
     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_useAdvancedBindlessMode)
+    if (funcName == GET_IMAGE_HEIGHT && m_addImplicitImageArgs)
     {
         imageFunc = &m_argMap[ImplicitArg::IMAGE_HEIGHT];
     }
-    else if (funcName == GET_IMAGE_WIDTH && !m_useAdvancedBindlessMode)
+    else if (funcName == GET_IMAGE_WIDTH && m_addImplicitImageArgs)
     {
         imageFunc = &m_argMap[ImplicitArg::IMAGE_WIDTH];
     }
-    else if (funcName == GET_IMAGE_DEPTH && !m_useAdvancedBindlessMode)
+    else if (funcName == GET_IMAGE_DEPTH && m_addImplicitImageArgs)
     {
         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_useAdvancedBindlessMode)
+    else if ((funcName == GET_IMAGE1D_ARRAY_SIZE || funcName == GET_IMAGE2D_ARRAY_SIZE) && m_addImplicitImageArgs)
     {
         imageFunc = &m_argMap[ImplicitArg::IMAGE_ARRAY_SIZE];
     }
@@ -197,21 +197,9 @@ 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))
+        if (Argument * arg = dyn_cast<Argument>(callArg); arg && isSamplerArgument(arg))
         {
-            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()));
+            imageFunc->insert(arg->getArgNo());
             return;
         }
     }

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

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