Fix handling of printf with excess arguments

Printf can have more arguments than conversion specifiers in format
string, example:

```c
printf("text with exhausted format\n", i++, evaluated = modify_char());
```

According to printf specification:
"If the format is exhausted while arguments remain, the excess arguments
are evaluated..."

The issue is that IGC writes excess arguments into printf buffer even
if they don't have corresponding conversion specifiers in format string.
This change introduces counting mechanism for conversion specifiers in
format string and allows only for "non-excess" arguments to be written
into printf buffer.

This change also fixes the issue of writing tagged format string address
into printf buffer - it happens when a kernel addrspacecasts format string
pointer to generic pointer.

Author: aratajew

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

@@ -226,11 +226,6 @@ std::string OpenCLPrintfResolution::getEscapedString(const ConstantDataSequentia
 
 Value* OpenCLPrintfResolution::processPrintfString(Value* arg, Function& F)
 {
-    if (m_CGContext->enableZEBinary())
-    {
-        return arg;
-    }
-
     GlobalVariable* formatString = nullptr;
 
     if (isa<GlobalVariable>(arg))
@@ -241,6 +236,12 @@ Value* OpenCLPrintfResolution::processPrintfString(Value* arg, Function& F)
             IGC_ASSERT_MESSAGE(0, "Unexpected printf argument (expected string literal)");
             return ConstantInt::get(m_int32Type, -1);
         }
+
+        if (m_CGContext->enableZEBinary())
+        {
+            return arg;
+        }
+
         ConstantDataArray* formatStringConst = dyn_cast<ConstantDataArray>(formatString->getInitializer());
         std::string escaped_string = getEscapedString(formatStringConst);
 
@@ -373,6 +374,24 @@ static StoreInst* genStoreInternal(Value* Val, Value* Ptr, BasicBlock* InsertAtE
     return SI;
 }
 
+void OpenCLPrintfResolution::removeExcessArgs()
+{
+    SPrintfArgDescriptor* formatStringArgDesc = &m_argDescriptors[0];
+
+    Value* formatString = formatStringArgDesc->value;
+    IGC::SHADER_PRINTF_TYPE dataType = formatStringArgDesc->argType;
+    IGC_ASSERT(dataType == SHADER_PRINTF_STRING_LITERAL);
+
+    if (auto GV = dyn_cast<GlobalVariable>(formatString))
+    {
+        IGC_ASSERT(GV->hasInitializer());
+
+        unsigned int numFormatSpecifiers = getNumFormatSpecifiers(cast<ConstantDataArray>(GV->getInitializer()));
+        if (m_argDescriptors.size() > numFormatSpecifiers + 1)
+            m_argDescriptors.erase(m_argDescriptors.begin() + numFormatSpecifiers + 1, m_argDescriptors.end());
+    }
+}
+
 void OpenCLPrintfResolution::expandPrintfCall(CallInst& printfCall, Function& F)
 {
     /* Replace a printf call with IR instructions that fill the printf
@@ -449,6 +468,8 @@ void OpenCLPrintfResolution::expandPrintfCall(CallInst& printfCall, Function& F)
     // Scalarize vector arguments and substitute string arguments by their indices.
     preprocessPrintfArgs(printfCall);
 
+    removeExcessArgs();
+
     // writeOffset = atomic_add(bufferPtr, dataSize)
     Value *basebufferPtr = isPrintfBuiltin
                                ? printfCall.getArgOperand(0)
@@ -705,6 +726,29 @@ Value* OpenCLPrintfResolution::fixupPrintfArg(CallInst& printfCall, Value* arg,
     return arg;
 }
 
+unsigned OpenCLPrintfResolution::getNumFormatSpecifiers(const ConstantDataArray* dataArray)
+{
+    unsigned int count = 0;
+    StringRef formatString = dataArray->getRawDataValues();
+
+    const size_t length = formatString.size();
+    for (size_t i = 0; i < length; i++)
+    {
+        if (formatString[i] == '%')
+        {
+            if (i + 1 < length && formatString[i + 1] == '%')
+            {
+                i++;
+                continue;
+            }
+
+            count++;
+        }
+    }
+
+    return count;
+}
+
 void OpenCLPrintfResolution::preprocessPrintfArgs(CallInst& printfCall)
 {
     int i = 0;

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

@@ -88,6 +88,14 @@ namespace IGC
         // Replaces a printf call with a sequence of IR instrictions.
         void expandPrintfCall(llvm::CallInst& printfCall, llvm::Function& F);
 
+        // Removes excess arguments from m_argDescriptors vector. Excess arguments
+        // are arguments that do not have a corresponding format specifier in a
+        // format string.
+        void removeExcessArgs();
+
+        // Returns number of format specifiers in a format string.
+        unsigned getNumFormatSpecifiers(const llvm::ConstantDataArray* formatString);
+
         // Walkes over printf arguments (including the format string) and adds them to printfArgs.
         // If an argument has vector type, adds the vector elements instead.
         void preprocessPrintfArgs(llvm::CallInst& printfCall);