ZEBIN: Put a const string literal into .data.const.string section only if used by printf only.

Compiler can not distinguish a char array between a string literal. So,
to be safe we can only place a const string literal into the read-only
str section that is accessed by CPU when the string literal is used only
by printf. For all other cases, we need to place it into the read-only
data section.

Author: petechou

IGC/Compiler/CISACodeGen/CISABuilder.cpp

@@ -5697,6 +5697,7 @@ namespace IGC
     {
         ValueToSymbolList symbolTableList;
         CreateSymbolTable(symbolTableList);
+        ModuleMetaData* modMD = m_program->GetContext()->getModuleMetaData();
 
         // Get the data for zebin
         for (auto I : symbolTableList)
@@ -5720,10 +5721,13 @@ namespace IGC
                 }
                 // global constants and string literals
                 else {
-                    Constant* initializer = G->getInitializer();
-                    ConstantDataSequential* cds = dyn_cast<ConstantDataSequential>(initializer);
-                    if (cds && (cds->isCString() || cds->isString()))
+                    if (modMD->stringConstants.count(G))
+                    {
+                        ConstantDataSequential* cds = dyn_cast<ConstantDataSequential>(G->getInitializer());
+                        IGC_ASSERT(cds && (cds->isCString() || cds->isString()));
+                        (void) cds;
                         programSyms.globalStringConst.emplace_back((vISA::GenSymType)symbolEntry.s_type, symbolEntry.s_offset, symbolEntry.s_size, G->getName().str());
+                    }
                     else
                         programSyms.globalConst.emplace_back((vISA::GenSymType)symbolEntry.s_type, symbolEntry.s_offset, symbolEntry.s_size, G->getName().str());
                 }

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

@@ -87,3 +87,30 @@ void OpenCLPrintfAnalysis::addPrintfBufferArgs(Function& F)
     implicitArgs.push_back(ImplicitArg::PRINTF_BUFFER);
     ImplicitArgs::addImplicitArgs(F, implicitArgs, m_pMDUtils);
 }
+
+bool OpenCLPrintfAnalysis::isTopLevelUserPrintf(llvm::Value* V)
+{
+    // Recursively check the users of the value until reaching the top level
+    // user. Note that printf has no users.
+
+    // Base case: return true when the current value has no user and is a call
+    // to printf. Otherwise return false.
+    if (V->user_empty())
+    {
+        if (llvm::CallInst *call = llvm::dyn_cast<llvm::CallInst>(V))
+        {
+            return call->getCalledFunction()->getName() ==
+                OpenCLPrintfAnalysis::OPENCL_PRINTF_FUNCTION_NAME;
+        }
+        return false;
+    }
+
+    // Check users recursively.
+    for (auto user : V->users()) {
+        if (!isTopLevelUserPrintf(user))
+            return false;
+    }
+
+    // Return true as every top level user is a printf call.
+    return true;
+}

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

@@ -51,6 +51,10 @@ namespace IGC
 
         static const llvm::StringRef OPENCL_PRINTF_FUNCTION_NAME;
 
+        // Return true if every top level user is a printf call. Note that the
+        // function is expected to work only before printf is expanded.
+        static bool isTopLevelUserPrintf(llvm::Value* V);
+
     private:
 
         /// @brief  Adds an implicit argument for address of printf output buffer

IGC/Compiler/Optimizer/OpenCLPasses/ProgramScopeConstants/ProgramScopeConstantAnalysis.cpp

@@ -9,6 +9,7 @@ SPDX-License-Identifier: MIT
 #include "AdaptorCommon/ImplicitArgs.hpp"
 #include "AdaptorCommon/AddImplicitArgs.hpp"
 #include "Compiler/Optimizer/OpenCLPasses/ProgramScopeConstants/ProgramScopeConstantAnalysis.hpp"
+#include "Compiler/Optimizer/OpenCLPasses/OpenCLPrintf/OpenCLPrintfAnalysis.hpp"
 #include "Compiler/IGCPassSupport.h"
 #include "common/LLVMWarningsPush.hpp"
 #include <llvm/IR/Module.h>
@@ -160,11 +161,13 @@ bool ProgramScopeConstantAnalysis::runOnModule(Module& M)
             }
 
             // When ZeBin is enabled, constant variables that are string literals
-            // will be stored in the second const buffer
+            // used only by printf will be stored in the second const buffer.
             ConstantDataSequential* cds = dyn_cast<ConstantDataSequential>(initializer);
-            bool isStringConst = cds && (cds->isCString() || cds->isString());
-            if (Ctx->enableZEBinary() && isStringConst)
+            bool isPrintfOnlyStringConst = cds && (cds->isCString() || cds->isString()) &&
+                OpenCLPrintfAnalysis::isTopLevelUserPrintf(globalVar);
+            if (Ctx->enableZEBinary() && isPrintfOnlyStringConst)
             {
+                m_pModuleMd->stringConstants.insert(globalVar);
                 inlineProgramScopeBuffer = &m_pModuleMd->inlineConstantBuffers[1].Buffer;
             }
             else

IGC/common/MDFrameWork.cpp

@@ -43,6 +43,8 @@ template<typename Key, typename Value>
 MDNode* CreateNode(const std::map<Key, Value> &FuncMD, Module* module, StringRef name);
 template<typename Key, typename Value>
 MDNode* CreateNode(const MapVector<Key, Value> &FuncMD, Module* module, StringRef name);
+template<typename Key>
+MDNode* CreateNode(const std::set<Key> &FuncMD, Module* module, StringRef name);
 MDNode* CreateNode(const std::string &s, Module* module, StringRef name);
 MDNode* CreateNode(char* i, Module* module, StringRef name);
 
@@ -69,6 +71,8 @@ template<typename Key, typename Value>
 void readNode(std::map<Key, Value> &funcMD, MDNode* node);
 template<typename Key, typename Value>
 void readNode(MapVector<Key, Value> &funcMD, MDNode* node);
+template<typename Key>
+void readNode(std::set<Key> &funcMD, MDNode* node);
 
 template<typename T>
 void readNode(T &t, MDNode* node, StringRef name);
@@ -283,6 +287,20 @@ MDNode* CreateNode(const MapVector<Key, Value> &FuncMD, Module* module, StringRe
     return node;
 }
 
+template<typename Key>
+MDNode* CreateNode(const std::set<Key> &FuncMD, Module* module, StringRef name)
+{
+    std::vector<Metadata*> nodes;
+    nodes.push_back(MDString::get(module->getContext(), name));
+    int i = 0;
+    for ( auto it = FuncMD.begin(); it != FuncMD.end(); ++it)
+    {
+        nodes.push_back(CreateNode(*it, module, name.str() + "Set[" + std::to_string(i) + "]"));
+    }
+    MDNode* node = MDNode::get(module->getContext(), nodes);
+    return node;
+}
+
 void readNode(unsigned char &b, MDNode* node)
 {
     ValueAsMetadata* pVal = cast<ValueAsMetadata>(node->getOperand(1));
@@ -432,6 +450,18 @@ void readNode(MapVector<Key, Value> &keyMD, MDNode* node)
     return;
 }
 
+template<typename Key>
+void readNode(std::set<Key> &keyMD, MDNode* node)
+{
+    for (unsigned k = 1; k < node->getNumOperands(); k++)
+    {
+        Key key;
+        readNode(key, cast<MDNode>(node->getOperand(k)));
+        keyMD.insert(key);
+    }
+    return;
+}
+
 template<typename T>
 void readNode(T &t, MDNode* node, StringRef name)
 {

IGC/common/MDFrameWork.h

@@ -12,6 +12,7 @@ SPDX-License-Identifier: MIT
 
 #include <string>
 #include <map>
+#include <set>
 #include <vector>
 #include <array>
 #include <optional>
@@ -640,6 +641,7 @@ namespace IGC
         std::map<uint32_t, std::array<uint32_t, 4>> inlineDynTextures;
         std::vector<InlineResInfo> inlineResInfoData;
         ImmConstantInfo immConstant;
+        std::set<llvm::GlobalVariable*> stringConstants;
         std::vector<InlineProgramScopeBuffer> inlineConstantBuffers;
         std::vector<InlineProgramScopeBuffer> inlineGlobalBuffers;
         std::vector<PointerProgramBinaryInfo> GlobalPointerProgramBinaryInfos;