PromoteBools::promoteFunction() setAttributes fix

promoteFunction method when setting attributes for the newly created
function uses old function's attribute list, which in case some
attributes got promoted causes the new function to inherit unpromoted
attributes. This commit fixes it by defining a new method that iterates
over the attribute list, checking for each whether it's been promoted
and adding it to the new function.

Author: smilczek

IGC/AdaptorOCL/preprocess_spvir/PromoteBools.cpp

@@ -12,6 +12,8 @@ SPDX-License-Identifier: MIT
 #include "llvmWrapper/IR/DerivedTypes.h"
 #include "llvmWrapper/IR/Instructions.h"
 #include "llvmWrapper/IR/Type.h"
+#include "llvmWrapper/IR/Function.h"
+#include "llvmWrapper/IR/Attributes.h"
 #include "llvmWrapper/Support/Alignment.h"
 #include "llvmWrapper/Transforms/Utils/Cloning.h"
 #include <llvm/IR/Module.h>
@@ -500,6 +502,56 @@ Value* PromoteBools::getOrCreatePromotedValue(Value* value)
     return newValue;
 }
 
+void PromoteBools::setPromotedAttributes(Function* newFunction, AttributeList& attributeList)
+{
+#if LLVM_VERSION_MAJOR >= 12
+    auto getPromoted = [this, &newFunction](llvm::Attribute attr)
+        {
+            if (attr.isTypeAttribute())
+            {
+                return attr.getWithNewType(newFunction->getContext(),
+                    getOrCreatePromotedType(attr.getValueAsType()));
+            }
+            else
+            {
+                return attr;
+            }
+        };
+
+    // set function attributes
+    AttrBuilder attrBuilder(newFunction->getContext());
+    for (auto attr : IGCLLVM::getFnAttrs(attributeList))
+    {
+        attrBuilder.addAttribute(getPromoted(attr));
+    }
+    IGCLLVM::addFnAttrs(newFunction, attrBuilder);
+
+    // set return attributes
+    attrBuilder.clear();
+    for (auto attr : IGCLLVM::getRetAttrs(attributeList))
+    {
+        attrBuilder.addAttribute(getPromoted(attr));
+    }
+    IGCLLVM::addRetAttrs(newFunction, attrBuilder);
+
+    // set params' attributes
+    for (size_t i = 0; i < newFunction->arg_size(); i++)
+    {
+        if (!attributeList.hasParamAttrs(i))
+        {
+            continue;
+        }
+
+        attrBuilder.clear();
+        for (auto attr : IGCLLVM::getParamAttrs(attributeList, i))
+        {
+            attrBuilder.addAttribute(getPromoted(attr));
+        }
+        newFunction->addParamAttrs(i, attrBuilder);
+    }
+#endif // LLVM_VERSION_MAJOR >= 12
+}
+
 Function* PromoteBools::promoteFunction(Function* function)
 {
     if (!function
@@ -516,8 +568,11 @@ Function* PromoteBools::promoteFunction(Function* function)
         function->getName() + ".promoted",
         function->getParent()
     );
+
     newFunction->setCallingConv(function->getCallingConv());
-    newFunction->setAttributes(function->getAttributes());
+
+    AttributeList attributeList = function->getAttributes();
+    setPromotedAttributes(newFunction, attributeList);
 
     // Clone and fix function body
     if (!function->isDeclaration())
@@ -532,9 +587,17 @@ Function* PromoteBools::promoteFunction(Function* function)
             newFunctionArgIt->setName(functionArgIt->getName());
             argsMap[&*functionArgIt++] = newFunctionArgIt++;
         }
+
+        // Create a copy of the promoted attributes list so that
+        // we can reset it after CloneFunctionInto
+        AttributeList newAttributeList = newFunction->getAttributes();
+
         IGCLLVM::CloneFunctionInto(newFunction, function, argsMap,
             IGCLLVM::CloneFunctionChangeType::GlobalChanges, returns);
 
+        // CloneFunctionInto set the potentially unpromoted attrs again.
+        newFunction->setAttributes(newAttributeList);
+
         // Fix body
         for (auto& arg : function->args())
         {

IGC/AdaptorOCL/preprocess_spvir/PromoteBools.h

@@ -79,6 +79,8 @@ namespace IGC
             });
         }
 
+        void setPromotedAttributes(llvm::Function* newFunction, llvm::AttributeList& attributeList);
+
         llvm::Value* getOrCreatePromotedValue(llvm::Value* value);
         llvm::Function* promoteFunction(llvm::Function* function);
         llvm::GlobalVariable* promoteGlobalVariable(llvm::GlobalVariable* globalVariable);

IGC/Compiler/tests/PromoteBools/promote_attrs.ll

@@ -0,0 +1,19 @@
+;=========================== begin_copyright_notice ============================
+;
+; Copyright (C) 2023 Intel Corporation
+;
+; SPDX-License-Identifier: MIT
+;
+;============================ end_copyright_notice =============================
+
+; REQUIRES: system-linux
+; RUN: igc_opt -igc-promote-bools -S %s -o %t.ll
+; RUN: FileCheck %s --input-file=%t.ll
+
+; CHECK-NOT: .unpromoted
+
+%struct = type { [4 x <8 x i1*>], [4 x <8 x i1>*]* }
+
+define spir_func void @prom_attr(%struct* byval(%struct) align 8 %0) {
+  ret void
+}

IGC/WrapperLLVM/include/llvmWrapper/IR/Attributes.h

@@ -92,6 +92,22 @@ namespace IGCLLVM {
 #endif
     }
 
+    inline llvm::AttributeList addFnAttributes(llvm::AttributeList &Attrs, llvm::LLVMContext& C, llvm::AttrBuilder& B) {
+#if LLVM_VERSION_MAJOR >= 14
+        return Attrs.addFnAttributes(C, B);
+#else
+        return Attrs.addAttributes(C, llvm::AttributeList::FunctionIndex, B);
+#endif
+    }
+
+    inline llvm::AttributeList addRetAttributes(llvm::AttributeList &Attrs, llvm::LLVMContext& C, llvm::AttrBuilder& B) {
+#if LLVM_VERSION_MAJOR >= 14
+        return Attrs.addRetAttributes(C, B);
+#else
+        return Attrs.addAttributes(C, llvm::AttributeList::ReturnIndex, B);
+#endif
+    }
+
     class AttrBuilder : public llvm::AttrBuilder {
     public:
         AttrBuilder() = delete;

IGC/WrapperLLVM/include/llvmWrapper/IR/Function.h

@@ -39,6 +39,22 @@ inline void addRetAttr(llvm::Function *F, llvm::Attribute::AttrKind Kind) {
 #endif
 }
 
+inline void addRetAttrs(llvm::Function* F, llvm::AttrBuilder &B) {
+#if LLVM_VERSION_MAJOR < 14
+  F->addAttributes(llvm::AttributeList::ReturnIndex, B);
+#else
+  F->addRetAttrs(B);
+#endif
+}
+
+inline void addFnAttrs(llvm::Function* F, llvm::AttrBuilder &B) {
+#if LLVM_VERSION_MAJOR < 14
+  F->addAttributes(llvm::AttributeList::FunctionIndex, B);
+#else
+  F->addFnAttrs(B);
+#endif
+}
+
 inline bool onlyWritesMemory(llvm::Function *F) {
 #if LLVM_VERSION_MAJOR < 14
   return F->doesNotReadMemory();