The dummy values in the m_DRL were previously defined as a load from a null pointer, which is an error.

A load from a null pointer can be a valid code if that pointer occupies a custom target-specific address space.
SCMEntry which is a load from a null pointer causes the associated DRLEntry to not be deleted from the m_DRL.

Author: Krebrov001

IGC/Compiler/Optimizer/Scalarizer.cpp

@@ -88,6 +88,7 @@ ScalarizeFunction::~ScalarizeFunction()
 {
     releaseAllSCMEntries();
     delete[] m_SCMAllocationArray;
+    destroyDummyFunc();
     V_PRINT(scalarizer, "ScalarizeFunction destructor\n");
 }
 
@@ -1090,17 +1091,14 @@ void ScalarizeFunction::obtainScalarizedValues(SmallVectorImpl<Value*>& retValue
         // Generate a DRL: dummy values, which will be resolved after all scalarization is complete.
         V_PRINT(scalarizer, "\t\t\t*** Not found. Setting DRL. \n");
         Type* dummyType = origType->getElementType();
-        V_PRINT(scalarizer, "\t\tCreate Dummy Scalar value/s (of type " << *dummyType << ")\n");
-        Constant* dummyPtr = ConstantPointerNull::get(dummyType->getPointerTo());
+        Function* dummy_function = getOrCreateDummyFunc(dummyType);
         DRLEntry newDRLEntry;
         newDRLEntry.unresolvedInst = origValue;
         newDRLEntry.dummyVals.resize(width);
         for (unsigned i = 0; i < width; i++)
         {
-            // Generate dummy "load" instruction (but don't really place in function)
-            retValues[i + destIdx] = new LoadInst(dummyPtr->getType()->getPointerElementType(),
-                                                  dummyPtr, "", false, IGCLLVM::getAlign(1));
-
+            // Generate dummy "call" instruction (but don't really place in function)
+            retValues[i + destIdx] = CallInst::Create(dummy_function);
             newDRLEntry.dummyVals[i] = retValues[i + destIdx];
         }
 
@@ -1298,10 +1296,16 @@ void ScalarizeFunction::resolveDeferredInstructions()
     std::map<Value*, Value*> dummyToScalarMap;
 
     // lambda to check if a value is a dummy instruction
-    auto isDummyValue = [](Value* val)->bool
+    auto isDummyValue = [this](Value* val) -> bool
     {
-        LoadInst* ld = dyn_cast<LoadInst>(val);
-        return (ld && isa<ConstantPointerNull>(ld->getPointerOperand()));
+        auto* call = dyn_cast<CallInst>(val);
+        if (!call) return false;
+        // If the Value is one of the dummy functions that we created.
+        for (const auto& function : createdDummyFunctions) {
+            if (call->getCalledFunction() == function.second)
+                return true;
+        }
+        return false;
     };
 
     for (auto deferredEntry = m_DRL.begin(); m_DRL.size() > 0;)

IGC/Compiler/Optimizer/Scalarizer.h

@@ -43,6 +43,7 @@ IN THE SOFTWARE.
 #include <string>
 #include <sstream>
 #include <set>
+#include <map>
 
 namespace IGC
 {
@@ -193,6 +194,26 @@ namespace IGC
         /// @brief release all allocations of SCM entries
         void releaseAllSCMEntries();
 
+        /// @brief create the dummy function which is called to signify a dummy value
+        inline llvm::Function* getOrCreateDummyFunc(llvm::Type* dummyType) {
+            if (createdDummyFunctions.find(dummyType) == createdDummyFunctions.end()) {
+                llvm::FunctionType* funcType = llvm::FunctionType::get(dummyType, false);
+                llvm::Function* function = llvm::Function::Create(funcType, llvm::Function::InternalLinkage);
+                createdDummyFunctions[dummyType] = function;
+                return function;
+            }
+            else
+                return createdDummyFunctions[dummyType];
+        }
+
+        /// @brief deletes the memory associated with all the created dynamic Function objects in the map
+        inline void destroyDummyFunc() {
+            for (auto& function : createdDummyFunctions) {
+                function.second->deleteValue();
+                function.second = nullptr;
+            }
+        }
+
         /// @brief An array of available SCMEntry's
         SCMEntry* m_SCMAllocationArray;
 
@@ -228,6 +249,9 @@ namespace IGC
 
         /// @brief This holds DataLayout of processed module
         const llvm::DataLayout* m_pDL;
+
+        /// @brief This holds all the created dummy functions throughout the lifetime of the pass, and manages their memory
+        std::map<llvm::Type*, llvm::Function*> createdDummyFunctions;
     };
 
 } // namespace IGC