Add a flag to specify path and prefix for DebugInfo dumps

* Added a flag to specify path and prefix for DebugInfo dumps in a single option,
ignoring PID, binary and hash in produced filename(for LIT testing):

  {specified path and prefix}[usual kernel name w/o hash]

Author: dguzhaev

IGC/Compiler/CISACodeGen/DebugInfo.cpp

@@ -298,7 +298,14 @@ static void debugDump(const CShader* Shader, llvm::StringRef Ext,
         return;
 
     auto ExtStr = Ext.str();
-    std::string DumpName = IGC::Debug::GetDumpName(Shader, ExtStr.c_str());
+    IGC::Debug::DumpName DumpNameObj = IGC::Debug::GetDumpNameObj(Shader, ExtStr.c_str());
+    std::string DumpName = DumpNameObj.str();
+    if (IGC_IS_FLAG_ENABLED(DebugDumpNamePrefix))
+    {
+        auto hash = ShaderHash();
+        DumpNameObj = DumpNameObj.Hash(hash);
+        DumpName = DumpNameObj.AbsolutePath(IGC_GET_REGKEYSTRING(DebugDumpNamePrefix));
+    }
     FILE* const DumpFile = fopen(DumpName.c_str(), "wb+");
     if (nullptr == DumpFile)
         return;

IGC/Compiler/CISACodeGen/OpenCLKernelCodeGen.cpp

@@ -2761,7 +2761,9 @@ namespace IGC
             prevOffset = offset;
 
             // skip unused arguments
-            bool IsUnusedArg = (arg.getArgType() == KernelArg::ArgType::IMPLICIT_BUFFER_OFFSET) &&
+            bool IsUnusedArg =
+                (arg.getArgType() == KernelArg::ArgType::IMPLICIT_BUFFER_OFFSET ||
+                arg.getArgType() == KernelArg::ArgType::IMPLICIT_BINDLESS_OFFSET) &&
                 arg.getArg()->use_empty();
 
             // Runtime Values should not be processed any further. No annotations shall be created for them.

IGC/Compiler/PromoteStatelessToBindless.cpp

@@ -51,8 +51,8 @@ bool PromoteStatelessToBindless::runOnFunction(Function& F)
     if (HasStackCall)
         return false;
 
-    m_AccessToSrcPtrMap.clear();
-    m_AddressUsedSrcPtrMap.clear();
+    m_SrcPtrNeedStatelessAccess.clear();
+    m_SrcPtrToAccessMap.clear();
     if (!ClContext->m_InternalOptions.UseBindlessPrintf)
     {
         CheckPrintfBuffer(F);
@@ -83,6 +83,8 @@ void PromoteStatelessToBindless::CheckPrintfBuffer(Function& F)
 
 void PromoteStatelessToBindless::GetAccessInstToSrcPointerMap(Instruction* inst, Value* resourcePtr)
 {
+    bool canPromoteAccess = true;
+    auto modMD = getAnalysis<MetaDataUtilsWrapper>().getModuleMetaData();
     unsigned addrSpace = resourcePtr->getType()->getPointerAddressSpace();
 
     if (addrSpace != ADDRESS_SPACE_GLOBAL && addrSpace != ADDRESS_SPACE_CONSTANT)
@@ -103,14 +105,16 @@ void PromoteStatelessToBindless::GetAccessInstToSrcPointerMap(Instruction* inst,
                 break;
             case GenISAIntrinsic::GenISA_intatomicrawA64:
                 // Ignore a buffer in this intrinsic, keep it stateless.
-                return;
+                canPromoteAccess = false;
+                break;
             default:
                 IGC_ASSERT_MESSAGE(0, "Unsupported Instruction");
-                return;
+                canPromoteAccess = false;
+                break;
             }
         }
         else
-            return;
+            canPromoteAccess = false;
     }
 
     std::vector<Value*> tempList;
@@ -130,22 +134,36 @@ void PromoteStatelessToBindless::GetAccessInstToSrcPointerMap(Instruction* inst,
         // printf buffer address (through atomic add), see printf implementation in
         // OpenCLPrintfResolution.cpp. Currently keep printf implementation as stateless and
         // thus skip printf buffer for now.
-        return;
+        canPromoteAccess = false;
     }
 
-    m_promotedArgs.insert(cast<Argument>(srcPtr)->getArgNo());
-
-    // Save the instruction, which makes access (load/store/intrinsic) to the buffer
-    m_AccessToSrcPtrMap[inst] = srcPtr;
-    // Save the instruction, which generate an address of the buffer. This is the
-    // instruction right before the last one. The last one has to be the buffer itself.
-    if (tempList.size() > 1)
+    if (modMD->compOpt.UseLegacyBindlessMode)
     {
-        m_AddressUsedSrcPtrMap[tempList[tempList.size()-2]] = srcPtr;
+        if (!canPromoteAccess)
+        {
+            // In this case, the srcPtr is traced to a kernel arg, but the access instruction does not support
+            // bindless access, so we have to make all access stateless.
+            // Remove all access instructions of this srcPtr that may have been added in previous passes, to
+            // prevent promoting it to bindless.
+            m_SrcPtrNeedStatelessAccess.insert(srcPtr);
+            m_SrcPtrToAccessMap.erase(srcPtr);
+            return;
+        }
+        else if (m_SrcPtrNeedStatelessAccess.count(srcPtr) != 0)
+        {
+            return;
+        }
     }
-    else
+
+    if (canPromoteAccess)
     {
-        m_AddressUsedSrcPtrMap[inst] = srcPtr;
+        // Save the instruction, which makes access (load/store/intrinsic) to the buffer
+        Value* accessInst = inst;
+        // Save the instruction, which generate an address of the buffer. This is the
+        // instruction right before the last one. The last one has to be the buffer itself.
+        Value* addrUsedInst = (tempList.size() > 1) ? tempList[tempList.size() - 2] : inst;
+
+        m_SrcPtrToAccessMap[srcPtr].push_back(std::make_pair(accessInst, addrUsedInst));
     }
 }
 
@@ -164,85 +182,95 @@ void PromoteStatelessToBindless::PromoteStatelessToBindlessBuffers(Function& F)
 
     bool supportDynamicBTIsAllocation = ctx->platform.supportDynamicBTIsAllocation();
 
-    // Modify the reference to the buffer not through all users but only in instructions
-    // which are used in accesing (load/store) the buffer.
-    for (auto inst : m_AddressUsedSrcPtrMap)
+    for (auto iter : m_SrcPtrToAccessMap)
     {
-        Instruction* accessInst = cast<Instruction>(inst.first);
-        Argument* srcPtr = cast<Argument>(inst.second);
-
-        Value* nullSrcPtr = ConstantPointerNull::get(cast<PointerType>(srcPtr->getType()));
-        accessInst->replaceUsesOfWith(srcPtr, nullSrcPtr);
+        Argument* srcPtr = cast<Argument>(iter.first);
 
         ArgAllocMD* argInfo = &resourceAlloc->argAllocMDList[srcPtr->getArgNo()];
         IGC_ASSERT_MESSAGE((size_t)srcPtr->getArgNo() < resourceAlloc->argAllocMDList.size(), "ArgAllocMD List Out of Bounds");
-        // Update metadata to show bindless resource type
-        argInfo->type = ResourceTypeEnum::BindlessUAVResourceType;
+
+        if (modMD->compOpt.UseLegacyBindlessMode)
+        {
+            // Update metadata to show bindless resource type.
+            // Do this only for legacy mode, since the resource type of the original
+            // kernel arg needs to be bindless for it to be reinterpreted as a bindless offset.
+            // In advanced mode, always keep the original kernel arg as stateless, and use the
+            // IMPLICIT_BUFFER_OFFSET arg for bindless access.
+            argInfo->type = ResourceTypeEnum::BindlessUAVResourceType;
+        }
+
         if (supportDynamicBTIsAllocation)
         {
             argInfo->indexType =
                 resourceAlloc->uavsNumType +
-                (unsigned)std::distance(m_promotedArgs.begin(), m_promotedArgs.find(srcPtr->getArgNo()));
+                (unsigned)std::distance(m_SrcPtrToAccessMap.begin(), m_SrcPtrToAccessMap.find(srcPtr));
         }
-    }
-
-    if(supportDynamicBTIsAllocation)
-        resourceAlloc->uavsNumType += m_promotedArgs.size();
 
-    for (auto inst : m_AccessToSrcPtrMap)
-    {
-        Instruction* accessInst = cast<Instruction>(inst.first);
-        Argument* srcPtr = cast<Argument>(inst.second);
-
-        // Get the base bindless pointer
-        IGCIRBuilder<> builder(accessInst);
-        Value* resourcePtr = IGC::GetBufferOperand(accessInst);
-        IGC_ASSERT(resourcePtr);
-        unsigned bindlessAS = IGC::EncodeAS4GFXResource(*UndefValue::get(builder.getInt32Ty()), IGC::BINDLESS);
-        PointerType* basePointerType = PointerType::get(IGCLLVM::getNonOpaquePtrEltTy(resourcePtr->getType()), bindlessAS);
-        Value* bufferOffset = builder.CreatePtrToInt(resourcePtr, builder.getInt32Ty());
-
-        Value* basePointer = nullptr;
-        if (!modMD->compOpt.UseLegacyBindlessMode) {
-            Argument * srcOffset = implicitArgs.getNumberedImplicitArg(F, ImplicitArg::BINDLESS_OFFSET, srcPtr->getArgNo());
-            basePointer = builder.CreateIntToPtr(srcOffset, basePointerType);
-        } else {
-            basePointer = builder.CreatePointerCast(srcPtr, basePointerType);
-        }
-
-        if (LoadInst * load = dyn_cast<LoadInst>(accessInst))
-        {
-            Value* ldraw = IGC::CreateLoadRawIntrinsic(load, cast<Instruction>(basePointer), bufferOffset);
-            load->replaceAllUsesWith(ldraw);
-            load->eraseFromParent();
-        }
-        else if (StoreInst * store = dyn_cast<StoreInst>(accessInst))
+        // Loop through all access instructions for srcPtr
+        for (auto insts : iter.second)
         {
-            IGC::CreateStoreRawIntrinsic(store, cast<Instruction>(basePointer), bufferOffset);
-            store->eraseFromParent();
-        }
-        else if (GenIntrinsicInst * pIntr = dyn_cast<GenIntrinsicInst>(accessInst))
-        {
-            if (pIntr->getIntrinsicID() == GenISAIntrinsic::GenISA_simdBlockRead)
+            Instruction* accessInst = cast<Instruction>(insts.first);
+            Instruction* addrUsedInst = cast<Instruction>(insts.second);
+
+            // Modify the reference to the buffer not through all users but only in instructions
+            // which are used in accesing (load/store) the buffer.
+            Value* nullSrcPtr = ConstantPointerNull::get(cast<PointerType>(srcPtr->getType()));
+            addrUsedInst->replaceUsesOfWith(srcPtr, nullSrcPtr);
+
+            // Get the base bindless pointer
+            IGCIRBuilder<> builder(accessInst);
+            Value* resourcePtr = IGC::GetBufferOperand(accessInst);
+            IGC_ASSERT(resourcePtr);
+            unsigned bindlessAS = IGC::EncodeAS4GFXResource(*UndefValue::get(builder.getInt32Ty()), IGC::BINDLESS);
+            PointerType* basePointerType = PointerType::get(IGCLLVM::getNonOpaquePtrEltTy(resourcePtr->getType()), bindlessAS);
+            Value* bufferOffset = builder.CreatePtrToInt(resourcePtr, builder.getInt32Ty());
+
+            Value* basePointer = nullptr;
+            if (!modMD->compOpt.UseLegacyBindlessMode) {
+                Argument* srcOffset = implicitArgs.getNumberedImplicitArg(F, ImplicitArg::BINDLESS_OFFSET, srcPtr->getArgNo());
+                basePointer = builder.CreateIntToPtr(srcOffset, basePointerType);
+            }
+            else {
+                basePointer = builder.CreatePointerCast(srcPtr, basePointerType);
+            }
+
+            if (LoadInst* load = dyn_cast<LoadInst>(accessInst))
             {
-                Function* newBlockReadFunc = GenISAIntrinsic::getDeclaration(F.getParent(),
-                    GenISAIntrinsic::GenISA_simdBlockReadBindless,
-                    { accessInst->getType(), basePointer->getType(),Type::getInt32Ty(accessInst->getContext()) });
-                Instruction* newBlockRead = CallInst::Create(newBlockReadFunc, { basePointer, bufferOffset }, "", accessInst);
-                newBlockRead->setDebugLoc(pIntr->getDebugLoc());
-                accessInst->replaceAllUsesWith(newBlockRead);
-                accessInst->eraseFromParent();
+                Value* ldraw = IGC::CreateLoadRawIntrinsic(load, cast<Instruction>(basePointer), bufferOffset);
+                load->replaceAllUsesWith(ldraw);
+                load->eraseFromParent();
             }
-            else if (pIntr->getIntrinsicID() == GenISAIntrinsic::GenISA_simdBlockWrite)
+            else if (StoreInst* store = dyn_cast<StoreInst>(accessInst))
             {
-                Function* newBlockWriteFunc = GenISAIntrinsic::getDeclaration(F.getParent(),
-                    GenISAIntrinsic::GenISA_simdBlockWriteBindless,
-                    { basePointer->getType(), pIntr->getOperand(1)->getType(), Type::getInt32Ty(accessInst->getContext()) });
-                Instruction* newBlockWrite = CallInst::Create(newBlockWriteFunc, { basePointer, pIntr->getOperand(1), bufferOffset }, "", accessInst);
-                newBlockWrite->setDebugLoc(pIntr->getDebugLoc());
-                accessInst->replaceAllUsesWith(newBlockWrite);
-                accessInst->eraseFromParent();
+                IGC::CreateStoreRawIntrinsic(store, cast<Instruction>(basePointer), bufferOffset);
+                store->eraseFromParent();
+            }
+            else if (GenIntrinsicInst* pIntr = dyn_cast<GenIntrinsicInst>(accessInst))
+            {
+                if (pIntr->getIntrinsicID() == GenISAIntrinsic::GenISA_simdBlockRead)
+                {
+                    Function* newBlockReadFunc = GenISAIntrinsic::getDeclaration(F.getParent(),
+                        GenISAIntrinsic::GenISA_simdBlockReadBindless,
+                        { accessInst->getType(), basePointer->getType(),Type::getInt32Ty(accessInst->getContext()) });
+                    Instruction* newBlockRead = CallInst::Create(newBlockReadFunc, { basePointer, bufferOffset }, "", accessInst);
+                    newBlockRead->setDebugLoc(pIntr->getDebugLoc());
+                    accessInst->replaceAllUsesWith(newBlockRead);
+                    accessInst->eraseFromParent();
+                }
+                else if (pIntr->getIntrinsicID() == GenISAIntrinsic::GenISA_simdBlockWrite)
+                {
+                    Function* newBlockWriteFunc = GenISAIntrinsic::getDeclaration(F.getParent(),
+                        GenISAIntrinsic::GenISA_simdBlockWriteBindless,
+                        { basePointer->getType(), pIntr->getOperand(1)->getType(), Type::getInt32Ty(accessInst->getContext()) });
+                    Instruction* newBlockWrite = CallInst::Create(newBlockWriteFunc, { basePointer, pIntr->getOperand(1), bufferOffset }, "", accessInst);
+                    newBlockWrite->setDebugLoc(pIntr->getDebugLoc());
+                    accessInst->replaceAllUsesWith(newBlockWrite);
+                    accessInst->eraseFromParent();
+                }
             }
         }
     }
+
+    if(supportDynamicBTIsAllocation)
+        resourceAlloc->uavsNumType += m_SrcPtrToAccessMap.size();
 }

IGC/Compiler/PromoteStatelessToBindless.h

@@ -49,9 +49,16 @@ namespace IGC
         void PromoteStatelessToBindlessBuffers(llvm::Function& F) const;
         void CheckPrintfBuffer(llvm::Function& F);
 
-        std::set<unsigned> m_promotedArgs;
-        std::unordered_map<llvm::Value*, llvm::Value*> m_AccessToSrcPtrMap;
-        std::unordered_map<llvm::Value*, llvm::Value*> m_AddressUsedSrcPtrMap;
+        // Pair of bindless resource access instructions.
+        // The first is the actual instruction accessing the bindless buffer (load/store/etc)
+        // The second is the instruction accessing the address of the bindless buffer, which may or may not
+        // be identical to the first. Needed to convert to null address.
+        typedef std::pair<llvm::Value*, llvm::Value*> BindlessAccessInsts;
+        // Map of the srcPtr (kernel arg resource) to a vector of instructions accessing it
+        llvm::DenseMap<llvm::Value*, llvm::SmallVector<BindlessAccessInsts, 8>> m_SrcPtrToAccessMap;
+        // Tracks the set of resources that must have at least one stateless access
+        std::set<llvm::Value*> m_SrcPtrNeedStatelessAccess;
+
         llvm::Value* m_PrintfBuffer;
     };
 

IGC/common/igc_flags.h

@@ -344,6 +344,7 @@ DECLARE_IGC_REGKEY(bool,  ShaderDumpInstNamer,          false, "dump all unnamed
 DECLARE_IGC_REGKEY(debugString, ShaderDumpFilter,       0,     "Only dump files matching the given regex", true)
 DECLARE_IGC_REGKEY(bool, ElfDumpEnable,                 false, "dump ELF file", true)
 DECLARE_IGC_REGKEY(bool, ElfTempDumpEnable,             false, "dump temporary ELF files", true)
+DECLARE_IGC_REGKEY(debugString, DebugDumpNamePrefix,    0,     "Set a prefix to debug info dump filenames(with path) and drop hash info from them (for testing purposes)", true)
 DECLARE_IGC_REGKEY(bool, ShowFullVectorsInShaderDumps,  false, "print all elements of vectors in ShaderDumps, can dramatically increase ShaderDumps size", true)
 DECLARE_IGC_REGKEY(bool, PrintHexFloatInShaderDumpAsm,  true, "print floats in hex in asm dump", true)
 DECLARE_IGC_REGKEY(debugString, PrintAfter,             0,     "Take either all or comma/semicolon-separated list of pass names. If set, enable print LLVM IR after the given pass is done (mimic llvm print-after)", true)

IGC/ocloc_tests/lit.cfg.py

@@ -44,13 +44,19 @@
 if llvm_config.add_tool_substitutions([ToolSubst('ocloc', unresolved='break')], tool_dirs) is False:
   lit_config.note('Did not find ocloc in %s, ocloc will be used from system paths' % tool_dirs)
 
+llvm_config.add_tool_substitutions([ToolSubst('llvm-dwarfdump')], tool_dirs)
+llvm_config.add_tool_substitutions([ToolSubst('opt')], tool_dirs)
+
 if not config.regkeys_disabled:
   config.available_features.add('regkeys')
 
 if config.spirv_as_enabled:
   config.available_features.add('spirv-as')
   llvm_config.add_tool_substitutions([ToolSubst('spirv-as', unresolved='fatal')], tool_dirs)
 
+if config.is32b == "1":
+  config.available_features.add('sys32')
+
 if config.use_khronos_spirv_translator_in_sc == "1":
   config.available_features.add('khronos-translator')
   config.available_features.add('khronos-translator-' + config.llvm_version_major)

IGC/ocloc_tests/lit.site.cfg.py.in

@@ -26,6 +26,7 @@ config.spirv_as_enabled = "@IGC_BUILD__PROJ__spirv_as@"
 config.spirv_as_dir = "@IGC_SPIRV_AS_DIR@"
 config.use_khronos_spirv_translator_in_sc = "$<BOOL:@IGC_OPTION__USE_KHRONOS_SPIRV_TRANSLATOR_IN_SC@>"
 config.llvm_version_major = "@LLVM_VERSION_MAJOR@"
+config.is32b = "$<BOOL:$<EQUAL:@CMAKE_SIZEOF_VOID_P@,4>>"
 
 # Support substitution of the tools and libs dirs with user parameters. This is
 # used when we can't determine the tool dir at configuration time.