Changes in code.

Author: DianaChen

IGC/Compiler/Optimizer/OpenCLPasses/OpenCLPrintf/OpenCLPrintfResolution.cpp

@@ -106,6 +106,97 @@ char OpenCLPrintfResolution::ID = 0;
 // |      < vec_element_3 >       |
 // |------------------------------|
 
+// Looks for a GlobalVariable related with given value.
+// Returns nullptr if on the way to the global variable
+// found anything that is not :
+// * a CastInst
+// * a GEP with non-zero indices
+// * a SelectInst
+// * a PHINode
+// In case of select or phi instruction two operands are added to the vector.
+// In another case only one is added.
+inline SmallVector<Value*, 2> getGlobalVariable(Value* const v)
+{
+    SmallVector<Value *, 2> curr;
+    curr.push_back(v);
+
+    while (nullptr != curr.front() || nullptr != curr.back())
+    {
+        if (curr.size() == 1 && isa<GlobalVariable>(curr.front()))
+        {
+            break;
+        }
+        else if (curr.size() == 2 && (isa<GlobalVariable>(curr.front()) && isa<GlobalVariable>(curr.back())))
+        {
+            break;
+        }
+
+        if (CastInst* castInst = dyn_cast<CastInst>(curr.front()))
+        {
+            curr.pop_back();
+            curr.push_back(castInst->getOperand(0));
+        }
+        else if (GetElementPtrInst* getElemPtrInst = dyn_cast<GetElementPtrInst>(curr.front()))
+        {
+            if (curr.size() == 2)
+            {
+                if (GetElementPtrInst* getElemPtrInst2 = dyn_cast<GetElementPtrInst>(curr.back()))
+                {
+                    curr.pop_back();
+                    curr.pop_back();
+                    curr.push_back(getElemPtrInst->hasAllZeroIndices() ? getElemPtrInst->getPointerOperand() : nullptr);
+                    curr.push_back(getElemPtrInst2->hasAllZeroIndices() ? getElemPtrInst2->getPointerOperand() : nullptr);
+                }
+            }
+            else
+            {
+                curr.pop_back();
+                curr.push_back(getElemPtrInst->hasAllZeroIndices() ? getElemPtrInst->getPointerOperand() : nullptr);
+            }
+        }
+        else if (SelectInst* selectInst = dyn_cast<SelectInst>(curr.front()))
+        {
+            if (curr.size() == 2)
+            {
+                //  Nested select instruction is not supported
+                curr.front() = nullptr;
+                curr.back() = nullptr;
+            }
+            else
+            {
+                curr.pop_back();
+                curr.push_back(selectInst->getOperand(1));
+                curr.push_back(selectInst->getOperand(2));
+            }
+        }
+        else if (PHINode* phiNode = dyn_cast<PHINode>(curr.front()))
+        {
+            if (curr.size() == 2)
+            {
+                //  Nested phi instruction is not supported
+                curr.front() = nullptr;
+                curr.back() = nullptr;
+            }
+            else
+            {
+                curr.pop_back();
+                curr.push_back(phiNode->getOperand(0));
+                curr.push_back(phiNode->getOperand(1));
+            }
+        }
+        else
+        {
+            // Unhandled value type
+            curr.front() = nullptr;
+            if (curr.size() == 2)
+            {
+                curr.back() = nullptr;
+            }
+        }
+    }
+    return curr;
+}
+
 OpenCLPrintfResolution::OpenCLPrintfResolution() : FunctionPass(ID), m_atomicAddFunc(nullptr)
 {
     initializeOpenCLPrintfResolutionPass(*PassRegistry::getPassRegistry());
@@ -225,24 +316,24 @@ std::string OpenCLPrintfResolution::getEscapedString(const ConstantDataSequentia
     return Name;
 }
 
-Value* OpenCLPrintfResolution::processPrintfString(Value* arg, Function& F)
+Value* OpenCLPrintfResolution::processPrintfString(Value* printfArg, Function& F)
 {
     GlobalVariable* formatString = nullptr;
-
-    if (isa<GlobalVariable>(arg))
+    SmallVector<Value*, 2> curr = getGlobalVariable(printfArg);
+    SmallVector<unsigned int, 2> sv;
+    for (auto curr_i : curr)
     {
-        formatString = dyn_cast_or_null<GlobalVariable>(arg);
-        if ((nullptr == formatString) || !formatString->hasInitializer())
+        auto& curr_e = *curr_i;
+
+        formatString = dyn_cast_or_null<GlobalVariable>(&curr_e);
+        ConstantDataArray* formatStringConst = ((nullptr != formatString) && (formatString->hasInitializer())) ?
+            dyn_cast<ConstantDataArray>(formatString->getInitializer()) :
+            nullptr;
+
+        if (nullptr == formatStringConst)
         {
             IGC_ASSERT_MESSAGE(0, "Unexpected printf argument (expected string literal)");
-            return ConstantInt::get(m_int32Type, -1);
-        }
-        ConstantDataArray* formatStringConst = dyn_cast<ConstantDataArray>(formatString->getInitializer());
-        std::string escaped_string = getEscapedString(formatStringConst);
-
-        // preventing MD enries duplication
-        if (m_MapStringStringIndex.find(escaped_string) != m_MapStringStringIndex.end()) {
-            return ConstantInt::get(m_int32Type, m_MapStringStringIndex[escaped_string]);
+            return 0;
         }
 
         if (m_CGContext->type == ShaderType::RAYTRACING_SHADER)
@@ -259,107 +350,78 @@ Value* OpenCLPrintfResolution::processPrintfString(Value* arg, Function& F)
         Metadata* stringIndexVal = ConstantAsMetadata::get(
             ConstantInt::get(m_int32Type, m_stringIndex));
 
+        sv.push_back(m_stringIndex++);
+
+        std::string escaped_string = getEscapedString(formatStringConst);
         MDString* final_string = MDString::get(*m_context, escaped_string);
 
         args.push_back(stringIndexVal);
         args.push_back(final_string);
 
         MDNode* itemMDNode = MDNode::get(*m_context, args);
         namedMDNode->addOperand(itemMDNode);
-
-        m_MapStringStringIndex[escaped_string] = m_stringIndex;
-
-        return ConstantInt::get(m_int32Type, m_stringIndex++);
-    }
-    else if (CastInst* castInst = dyn_cast<CastInst>(arg))
-    {
-        return processPrintfString(castInst->getOperand(0), F);
-    }
-    else if (GetElementPtrInst* getElemPtrInst = dyn_cast<GetElementPtrInst>(arg))
-    {
-        IGC_ASSERT_MESSAGE(getElemPtrInst->hasAllZeroIndices(), "Only All Zero indices GEP supported");
-        return processPrintfString(getElemPtrInst->getPointerOperand(), F);
     }
-    else if (SelectInst* selectInst = dyn_cast<SelectInst>(arg))
-    {
-        SelectInst* selectInst2 = SelectInst::Create(selectInst->getOperand(0),
-            processPrintfString(selectInst->getOperand(1), F),
-            processPrintfString(selectInst->getOperand(2), F),
-            "", selectInst);
-        return selectInst2;
-    }
-    else if (PHINode* phiNode = dyn_cast<PHINode>(arg))
+
+    // Checks if the vector have two elements.
+    // If it has it adds a new phi/select instruction that is responsible
+    // for the correct execution of the basic instruction.
+    // This information is forwarded to the store instruction.
+    if (curr.size() == 2)
     {
-        unsigned inNum = phiNode->getNumIncomingValues();
-        PHINode* phiNode2 = PHINode::Create(m_int32Type, inNum, "", phiNode);
-        for (unsigned i = 0; i < inNum; i++)
+        if (GetElementPtrInst* getElemPtrInst = dyn_cast<GetElementPtrInst>(printfArg))
         {
-            phiNode2->addIncoming(processPrintfString(phiNode->getIncomingValue(i), F), phiNode->getIncomingBlock(i));
+            if (PHINode* phiNode = dyn_cast<PHINode>(getElemPtrInst->getPointerOperand()))
+            {
+                PHINode* phiNode2 = PHINode::Create(m_int32Type, 2, "", phiNode);
+                phiNode2->addIncoming(ConstantInt::get(m_int32Type, sv.front()), phiNode->getIncomingBlock(0));
+                phiNode2->addIncoming(ConstantInt::get(m_int32Type, sv.back()), phiNode->getIncomingBlock(1));
+                return phiNode2;
+            }
+        }
+        else if (SelectInst* selectInst = dyn_cast<SelectInst>(printfArg))
+        {
+            SelectInst* selectInst2 = SelectInst::Create(selectInst->getOperand(0), ConstantInt::get(m_int32Type, sv.front()),
+                ConstantInt::get(m_int32Type, sv.back()), "", selectInst);
+            return selectInst2;
+        }
+        else
+        {
+            IGC_ASSERT_MESSAGE(0, "Instructions in the vector are not supported!");
         }
-        return phiNode2;
-    }
-    else
-    {
-        IGC_ASSERT_MESSAGE(0, "Unsupported Instruction!");
     }
 
     ModuleMetaData* modMd = getAnalysis<MetaDataUtilsWrapper>().getModuleMetaData();
     if (IGC_IS_FLAG_ENABLED(EnableZEBinary) || modMd->compOpt.EnableZEBinary)
     {
-        return arg;
+        return printfArg;
     }
     else
     {
-        return ConstantInt::get(m_int32Type, -1);
+        return ConstantInt::get(m_int32Type, m_stringIndex - 1);
     }
 }
 
-// Checks pathes to global variables and returns true if all paths lead to constant strings.
-// Only these instructions acepted in pathes:
-// * a CastInst
-// * a GEP with all-zero indices
-// * a SelectInst
-// * a PHINode
-// It is expected that the paths are not looped.
-bool OpenCLPrintfResolution::argIsString(Value* arg)
+
+bool OpenCLPrintfResolution::argIsString(Value* printfArg)
 {
-    if (isa<GlobalVariable>(arg))
+    GlobalVariable* formatString = nullptr;
+    SmallVector<Value*, 2> curr = getGlobalVariable(printfArg);
+
+    for (auto curr_i : curr)
     {
-        GlobalVariable* formatString = dyn_cast_or_null<GlobalVariable>(arg);
+        auto& curr_e = *curr_i;
+        formatString = dyn_cast_or_null<GlobalVariable>(&curr_e);
         if (nullptr == formatString || !formatString->hasInitializer())
         {
             return false;
         }
         ConstantDataArray* formatStringConst = dyn_cast<ConstantDataArray>(formatString->getInitializer());
         if (!formatStringConst || !formatStringConst->isCString())
         {
-             return false;
-        }
-        return true;
-    }
-    else if (CastInst* castInst = dyn_cast<CastInst>(arg))
-    {
-        return argIsString(castInst->getOperand(0));
-    }
-    if (GetElementPtrInst* getElemPtrInst = dyn_cast<GetElementPtrInst>(arg))
-    {
-        return getElemPtrInst->hasAllZeroIndices() && argIsString(getElemPtrInst->getPointerOperand());
-    }
-    else if (SelectInst* selectInst = dyn_cast<SelectInst>(arg))
-    {
-        return argIsString(selectInst->getOperand(1)) &&
-            argIsString(selectInst->getOperand(2));
-    }
-    else if (PHINode* phiNode = dyn_cast<PHINode>(arg))
-    {
-        for (unsigned i = 0; i < phiNode->getNumIncomingValues(); i++)
-        {
-            if (!argIsString(phiNode->getIncomingValue(i)))
-                return false;
+            return false;
         }
-        return true;
     }
-    return false;
+    return true;
 }
 
 std::string OpenCLPrintfResolution::getPrintfStringsMDNodeName(Function& F)

IGC/Compiler/Optimizer/OpenCLPasses/OpenCLPrintf/OpenCLPrintfResolution.hpp

@@ -83,7 +83,7 @@ namespace IGC
 
         // If printfArg is string, adds the string into metadata.
         // Returns the string index if the argument is string, and -1 otherwise.
-        llvm::Value* processPrintfString(llvm::Value* arg, llvm::Function& F);
+        llvm::Value* processPrintfString(llvm::Value* printfArg, llvm::Function& F);
 
         // Replaces a printf call with a sequence of IR instrictions.
         void expandPrintfCall(llvm::CallInst& printfCall, llvm::Function& F);
@@ -129,7 +129,6 @@ namespace IGC
         llvm::LLVMContext* m_context;
         llvm::Function* m_atomicAddFunc;
         unsigned int         m_stringIndex;
-        std::map<std::string, unsigned int> m_MapStringStringIndex;
         llvm::IntegerType* m_ptrSizeIntType;
         llvm::IntegerType* m_int32Type;
         llvm::DebugLoc       m_DL;