[Autobackout][FunctionalRegression]Revert of change: d41f53b: Adding parameter attributes to some IGC intrinsics

sys-igc · igcbot · commit 8e2798fa77de · 2024-11-20T13:02:52.000+01:00
This change is to retain information about pointee types for particular arguments in some IGC intrinsics.
diff --git a/IGC/GenISAIntrinsics/GenIntrinsicFunctions.cpp b/IGC/GenISAIntrinsics/GenIntrinsicFunctions.cpp
@@ -101,27 +101,23 @@ class IntrinsicFunctionImp : public llvm::Function
         return false;
     }
 
-    static IntrinsicFunctionImp<id>* Get(llvm::Module& module, const llvm::ArrayRef<llvm::Type*>& overloadedTypes, const llvm::ArrayRef<llvm::Type*>& overloadedPointeeTys)
+    static IntrinsicFunctionImp<id>* Get(llvm::Module& module, const llvm::ArrayRef<llvm::Type*>& overloadedTypes)
     {
-        return llvm::cast<IntrinsicFunctionImp<id>>(GetDeclaration(module, overloadedTypes, overloadedPointeeTys));
+        return llvm::cast<IntrinsicFunctionImp<id>>(GetDeclaration(module, overloadedTypes));
     }
 
-    static llvm::Function* GetDeclaration(llvm::Module& module, const llvm::ArrayRef<llvm::Type*>& overloadedTypes, const llvm::ArrayRef<llvm::Type*>& overloadedPointeeTys)
+    static llvm::Function* GetDeclaration(llvm::Module& module, const llvm::ArrayRef<llvm::Type*>& overloadedTypes)
     {
-        return GetOrInsert(module, overloadedTypes, overloadedPointeeTys);
+        return GetOrInsert(module, overloadedTypes);
     }
 
-    static std::string GetName(const llvm::ArrayRef<llvm::Type*>& overloadedTypes, const llvm::ArrayRef<llvm::Type*>& overloadedPointeeTys)
+    static std::string GetName(const llvm::ArrayRef<llvm::Type*>& overloadedTypes)
     {
         std::string result = IntrinsicDefinitionT::scFunctionRootName;
         for (unsigned i = 0; i < overloadedTypes.size(); ++i)
         {
             result += "." + getMangledTypeStr(overloadedTypes[i]);
         }
-        for (unsigned i = 0; i < overloadedPointeeTys.size(); ++i)
-        {
-            result += "." + getMangledTypeStr(overloadedPointeeTys[i]);
-        }
         return result;
     }
 
@@ -143,12 +139,12 @@ class IntrinsicFunctionImp : public llvm::Function
 
 private:
 
-    static llvm::Function* GetOrInsert(llvm::Module& module, const llvm::ArrayRef<llvm::Type*>& overloadedTypes, const llvm::ArrayRef<llvm::Type*>& overloadedPointeeTys)
+    static llvm::Function* GetOrInsert(llvm::Module& module, const llvm::ArrayRef<llvm::Type*>& overloadedTypes)
     {
         llvm::LLVMContext& ctx = module.getContext();
-        std::string funcName = GetName(overloadedTypes, overloadedPointeeTys);
+        std::string funcName = GetName(overloadedTypes);
         llvm::FunctionType* pFuncType = GetType(ctx, overloadedTypes);
-        llvm::AttributeList attribs = GetAttributeList(ctx, overloadedPointeeTys);
+        llvm::AttributeList attribs = GetAttributeList(ctx);
         // There can never be multiple globals with the same name of different types,
         // because intrinsics must be a specific type.
         IGCLLVM::Module& M = static_cast<IGCLLVM::Module&>(module);
@@ -205,7 +201,7 @@ class IntrinsicFunctionImp : public llvm::Function
         {
             for (uint8_t i = 0; i < numArguments; i++)
             {
-                RetrieveType(i + 1, IntrinsicDefinitionT::scArguments[i].m_Type);
+                RetrieveType(i + 1, IntrinsicDefinitionT::scArgumentTypes[i]);
             }
         }
         // IGC_ASSERT(overloadedTypeIndex == overloadedTypes.size());
@@ -222,60 +218,16 @@ class IntrinsicFunctionImp : public llvm::Function
         return llvm::FunctionType::get(resultTy, argTys, false);
     }
 
-    static llvm::AttributeList GetAttributeList(llvm::LLVMContext& ctx, const llvm::ArrayRef<llvm::Type*>& overloadedPointeeTys)
+    static llvm::AttributeList GetAttributeList(llvm::LLVMContext& ctx)
     {
         // 1. Instantiate regular attributes for the given intrinsic
         constexpr auto& attributeKinds = IntrinsicDefinitionT::scAttributeKinds;
         auto mainAttrList = llvm::AttributeList::get(
             ctx, llvm::AttributeList::FunctionIndex, attributeKinds);
         // 2. Gather the memory attribute(s) in a separate routine
         auto memoryAB = IntrinsicDefinitionT::scMemoryEffects.getAsAttrBuilder(ctx);
-        mainAttrList = mainAttrList.addFnAttributes(ctx, memoryAB);
-        // 3. Gather parameter attributes
-        uint8_t overloadedTypeIndex = 0;
-        auto RetrieveParamAttr = [&overloadedTypeIndex, &ctx, &overloadedPointeeTys, &mainAttrList](uint8_t index, const ArgumentDescription& arg)
-            {
-                if (arg.m_AttrKind == llvm::Attribute::None)
-                {
-                    return;
-                }
-                IGC_ASSERT_MESSAGE(
-                    arg.m_AttrKind == llvm::Attribute::ByRef ||
-                    arg.m_AttrKind == llvm::Attribute::ByVal ||
-                    arg.m_AttrKind == llvm::Attribute::StructRet,
-                    "Used an invalid(?) parameter attribute kind");
-                switch (arg.m_Type.m_ID)
-                {
-                case TypeID::Pointer:
-                {
-                    llvm::Type* pointeeType = nullptr;
-                    if (overloadedTypeIndex < overloadedPointeeTys.size() && arg.m_Type.IsOverloadable())
-                    {
-                        pointeeType = overloadedPointeeTys[overloadedTypeIndex++];
-                    }
-                    else
-                    {
-                        pointeeType = arg.m_Type.m_Pointer.m_Type.GetType(ctx);
-                    }
-                    mainAttrList = mainAttrList.addParamAttribute(ctx, { index }, llvm::Attribute::get(ctx, arg.m_AttrKind, pointeeType));
-                    break;
-                }
-                default:
-                    IGC_ASSERT_MESSAGE(0, "A parameter attribute used for non-pointer function argument.");
-                    break;
-                }
-            };
-
-        constexpr uint8_t numArguments = static_cast<uint8_t>(Argument::Count);
-        if constexpr (numArguments > 0)
-        {
-            for (uint8_t i = 0; i < numArguments; i++)
-            {
-                RetrieveParamAttr(i, IntrinsicDefinitionT::scArguments[i]);
-            }
-        }
-
-        return mainAttrList;
+        // Return a merged collection
+        return mainAttrList.addFnAttributes(ctx, memoryAB);
     }
 };
 
@@ -293,14 +245,14 @@ static constexpr auto GetDeclarationFuncArray()
     return GetDeclarationFuncArrayImp(seq);
 }
 
-llvm::Function* GetDeclaration(llvm::Module* pModule, llvm::GenISAIntrinsic::ID id, llvm::ArrayRef<llvm::Type*> overloadedTys, llvm::ArrayRef<llvm::Type*> overloadedPointeeTys)
+llvm::Function* GetDeclaration(llvm::Module* pModule, llvm::GenISAIntrinsic::ID id, llvm::ArrayRef<llvm::Type*> overloadedTys)
 {
     constexpr auto funcArray = GetDeclarationFuncArray();
     llvm::Function* pResult = nullptr;
     uint32_t index = static_cast<uint32_t>(id) - scBeginIntrinsicIndex;
     if (index < funcArray.size())
     {
-        pResult = funcArray[index](*pModule, overloadedTys, overloadedPointeeTys);
+        pResult = funcArray[index](*pModule, overloadedTys);
     }
     return pResult;
 }
@@ -319,14 +271,14 @@ static constexpr auto GetNameFuncArray()
     return GetNameFuncArrayImp(seq);
 }
 
-std::string GetName(llvm::GenISAIntrinsic::ID id, llvm::ArrayRef<llvm::Type*> overloadedTys, llvm::ArrayRef<llvm::Type*> overloadedPointeeTys)
+std::string GetName(llvm::GenISAIntrinsic::ID id, llvm::ArrayRef<llvm::Type*> overloadedTys)
 {
     constexpr auto funcArray = GetNameFuncArray();
     std::string result;
     uint32_t index = static_cast<uint32_t>(id) - scBeginIntrinsicIndex;
     if (index < funcArray.size())
     {
-        result = funcArray[index](overloadedTys, overloadedPointeeTys);
+        result = funcArray[index](overloadedTys);
     }
     return result;
 }
diff --git a/IGC/GenISAIntrinsics/GenIntrinsicFunctions.h b/IGC/GenISAIntrinsics/GenIntrinsicFunctions.h
@@ -28,10 +28,10 @@ std::string getMangledTypeStr(llvm::Type* Ty);
 
 const char* GetIntrinsicPrefixName();
 
-std::string GetName(llvm::GenISAIntrinsic::ID id, llvm::ArrayRef<llvm::Type*> OverloadedTys, llvm::ArrayRef<llvm::Type*> overloadedPointeeTys);
+std::string GetName(llvm::GenISAIntrinsic::ID id, llvm::ArrayRef<llvm::Type*> OverloadedTys);
 
 llvm::GenISAIntrinsic::IntrinsicComments GetIntrinsicComments(llvm::GenISAIntrinsic::ID id);
 
-llvm::Function* GetDeclaration(llvm::Module* pModule, llvm::GenISAIntrinsic::ID id, llvm::ArrayRef<llvm::Type*> overloadedTys, llvm::ArrayRef<llvm::Type*> overloadedPointeeTys);
+llvm::Function* GetDeclaration(llvm::Module* pModule, llvm::GenISAIntrinsic::ID id, llvm::ArrayRef<llvm::Type*> overloadedTys);
 
 } // namespace IGC
diff --git a/IGC/GenISAIntrinsics/GenIntrinsics.cpp b/IGC/GenISAIntrinsics/GenIntrinsics.cpp
@@ -75,19 +75,19 @@ namespace llvm
 namespace GenISAIntrinsic
 {
 
-std::string getName(ID id, ArrayRef<Type*> OverloadedTys /*= None*/, ArrayRef<Type*> OverloadedPointeeTys /*= None*/)
+std::string getName(ID id, ArrayRef<Type*> OverloadedTys /*= None*/)
 {
-    return IGC::GetName(id, OverloadedTys, OverloadedPointeeTys);
+    return IGC::GetName(id, OverloadedTys);
 }
 
 IntrinsicComments getIntrinsicComments(ID id)
 {
     return IGC::GetIntrinsicComments(id);
 }
 
-Function* getDeclaration(Module* M, ID id, ArrayRef<Type*> OverloadedTys /*= None*/, ArrayRef<Type*> OverloadedPointeeTys /*= None*/)
+Function* getDeclaration(Module* M, ID id, ArrayRef<Type*> OverloadedTys /*= None*/)
 {
-    return IGC::GetDeclaration(M, id, OverloadedTys, OverloadedPointeeTys);
+    return IGC::GetDeclaration(M, id, OverloadedTys);
 }
 
 ID getIntrinsicID(const Function* F, bool useContextWrapper /*= true*/)
diff --git a/IGC/GenISAIntrinsics/GenIntrinsics.h b/IGC/GenISAIntrinsics/GenIntrinsics.h
@@ -25,7 +25,7 @@ namespace GenISAIntrinsic
 
 /// Intrinsic::getName(ID) - Return the LLVM name for an intrinsic, such as
 /// "llvm.ppc.altivec.lvx".
-std::string getName(ID id, ArrayRef<Type*> Tys = {}, ArrayRef<Type*> OverloadedPointeeTys = {});
+std::string getName(ID id, ArrayRef<Type*> Tys = {});
 
 
 struct IntrinsicComments
@@ -53,9 +53,9 @@ IntrinsicComments getIntrinsicComments(ID id);
 ///    Type Ts[2]{int2, int2}: to resolve to the first instance.
 ///    Type Ts[2]{int4, int4}: to resolve to the second.
 #if defined(ANDROID) || defined(__linux__)
-__attribute__ ((visibility ("default"))) Function *getDeclaration(Module *M, ID id, ArrayRef<Type*> OverloadedTys = {}, ArrayRef<Type*> OverloadedPointeeTys = {});
+__attribute__ ((visibility ("default"))) Function *getDeclaration(Module *M, ID id, ArrayRef<Type*> OverloadedTys = {});
 #else
-Function *getDeclaration(Module *M, ID id, ArrayRef<Type*> OverloadedTys = {}, ArrayRef<Type*> OverloadedPointeeTys = {});
+Function *getDeclaration(Module *M, ID id, ArrayRef<Type*> OverloadedTys = {});
 #endif
 
 //Override of isIntrinsic method defined in Function.h
diff --git a/IGC/GenISAIntrinsics/LlvmTypesMapping.h b/IGC/GenISAIntrinsics/LlvmTypesMapping.h
@@ -11,7 +11,6 @@ SPDX-License-Identifier: MIT
 
 #include "common/LLVMWarningsPush.hpp"
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/IR/Attributes.h"
 #include "common/LLVMWarningsPop.hpp"
 
 namespace llvm
@@ -410,18 +409,6 @@ struct TypeDescription
     const TypeID m_ID;
 };
 
-struct ArgumentDescription
-{
-    constexpr ArgumentDescription(const TypeDescription& type, llvm::Attribute::AttrKind attrKind = llvm::Attribute::None) :
-        m_Type(type),
-        m_AttrKind(attrKind)
-    {
-    }
-
-    const TypeDescription& m_Type;
-    llvm::Attribute::AttrKind m_AttrKind;
-};
-
 constexpr bool IsOverloadable(const TypeDescription& type)
 {
     return type.IsOverloadable();
diff --git a/IGC/GenISAIntrinsics/generator/Intrinsic_definition_objects.py b/IGC/GenISAIntrinsics/generator/Intrinsic_definition_objects.py
@@ -151,36 +151,6 @@ def AttributeID_constructor(loader, node):
 
 yaml.SafeLoader.add_constructor(u'!AttributeID', AttributeID_constructor)
 
-class ParamAttributeID(Enum):
-    ByRef = 0
-    ByVal = 1
-    StructRet = 2
-
-    def __str__(self):
-        return self.name
-
-    def __repr__(self):
-        return '%s("%s")' % (self.__class__.__name__, self)
-
-    @classmethod
-    def from_str(cls, value : str):
-        for key, val in cls.__members__.items():
-            if key == value:
-                return val
-        else:
-            raise ValueError("{value} is not present in {cls.__name__}")
-
-def ParamAttributeID_representer(dumper, data):
-    return dumper.represent_scalar(u'!ParamAttributeID', u'%s' % str(data), style='"')
-
-yaml.add_representer(ParamAttributeID, ParamAttributeID_representer)
-
-def ParamAttributeID_constructor(loader, node):
-    value = loader.construct_scalar(node)
-    return ParamAttributeID.from_str(value)
-
-yaml.SafeLoader.add_constructor(u'!ParamAttributeID', ParamAttributeID_constructor)
-
 class MemoryLocation(Enum):
     ArgMem = 0
     InaccessibleMem = 1
@@ -490,36 +460,27 @@ def from_yaml(cls, loader, node):
         arg_dict = loader.construct_mapping(node, deep=True)
         return cls(**arg_dict)
 
-    def __init__(self, name : str, type_definition : TypeDefinition, comment : str, param_attr : ParamAttributeID = None):
+    def __init__(self, name : str, type_definition : TypeDefinition, comment : str):
         self.name = name
         self.type_definition = type_definition
         self.comment = QuotedString(comment)
-        if param_attr:
-            self.param_attr = param_attr
 
     def __repr__(self):
-        repr_str = "name=%r" % (self.name)
-        repr_str += ", type_definition=%r" % (self.type_definition)
-        repr_str += ", comment=%r" % (self.comment)
-        if hasattr(self, 'param_attr'):
-            repr_str += ", param_attr=%r" % str(self.param_attr)
-        return "%s(%r)" % (
-            self.__class__.__name__, repr_str)
+        return "%s(name=%r, type_definition=%r, comment=%r)" % (
+            self.__class__.__name__, self.name, self.type_definition, self.comment)
 
     def to_dict(self):
         res =  {
             "name": self.name,
             "type_definition": self.type_definition.to_dict(),
             "comment": self.comment
         }
-        if hasattr(self, 'param_attr'):
-            res["param_attr"] = str(self.param_attr)
         return res
 
     @staticmethod
     def from_dict(json_dct : dict):
         type_definition = TypeDefinition.from_dict(json_dct['type_definition'])
-        return ArgumentDefinition(json_dct['name'], type_definition, json_dct['comment'], json_dct['param_attr'])
+        return ArgumentDefinition(json_dct['name'], type_definition, json_dct['comment'])
 
 class MemoryRestriction(SafeYAMLObject):
 
diff --git a/IGC/GenISAIntrinsics/generator/Intrinsic_generator.py b/IGC/GenISAIntrinsics/generator/Intrinsic_generator.py
@@ -122,16 +122,10 @@ def get_type_definition(type_def):
                 output = "AnyTypeHolderT<>"
         return output
 
-    @classmethod
-    def get_argument_entry(cls, arg, is_last):
-        output = cls.get_type_definition(arg.type_definition)
+    @staticmethod
+    def get_argument_type_entry(type_def, is_last):
+        output = IntrinsicFormatter.get_type_definition(type_def)
         output = "{}::scType".format(output)
-        if hasattr(arg, 'param_attr'):
-            # a param attribute is supported only for pointer function arguments to preserve their pointee types
-            if arg.type_definition.ID != TypeID.Pointer:
-                sys.exit(1)
-            output += ", {}".format(cls.get_attribute_entry(arg.param_attr, is_last=True))
-        output = "ArgumentDescription({})".format(output)
         if not is_last:
             output = "{},".format(output)
         return output
@@ -157,13 +151,6 @@ def get_attribute_entry(attribute, is_last):
             output = "{},".format(output)
         return output
 
-    @staticmethod
-    def get_param_attribute_entry(param_attribute, is_last):
-        output = 'std::make_pair(llvm::Attribute::{}, {})'.format(param_attribute.name, param_attribute.index)
-        if not is_last:
-            output = "{},".format(output)
-        return output
-
     @staticmethod
     def get_memory_effects_instance(memory_restriction : MemoryRestriction):
         modref_arg = "IGCLLVM::ModRefInfo::{}".format(memory_restriction.memory_access)
diff --git a/IGC/GenISAIntrinsics/generator/input/Intrinsic_definitions.yml b/IGC/GenISAIntrinsics/generator/input/Intrinsic_definitions.yml
@@ -10800,7 +10800,6 @@ intrinsics:
                 name: Arg2
                 type_definition: *p_any_
                 comment: "User defined intersection attributes struct"
-                param_attr: !ParamAttributeID "ByRef"
         attributes:
             - !AttributeID "NoUnwind"
     - !<IntrinsicDefinition>
diff --git a/IGC/GenISAIntrinsics/generator/templates/GenIntrinsicDefinition.h.mako b/IGC/GenISAIntrinsics/generator/templates/GenIntrinsicDefinition.h.mako
@@ -18,7 +18,6 @@ SPDX-License-Identifier: MIT
 
 #include <string_view>
 #include <array>
-#include <utility>
 
 namespace IGC
 {
@@ -47,10 +46,9 @@ public:
     };
     % if hasattr(el, 'arguments') and el.arguments and len(el.arguments) > 0:
 
-    ## All comments are stored in another member due to preserve `constexpr`
-    static constexpr std::array<ArgumentDescription, static_cast<uint32_t>(Argument::Count)> scArguments{
+    static constexpr std::array<TypeDescription, static_cast<uint32_t>(Argument::Count)> scArgumentTypes{
         % for arg in el.arguments:
-        ${IntrinsicFormatter.get_argument_entry(arg, loop.last)}
+        ${IntrinsicFormatter.get_argument_type_entry(arg.type_definition, loop.last)}
         % endfor
     };
     % endif
@@ -68,16 +66,8 @@ public:
         % endfor
     };
     % endif
-    % if hasattr(el, 'param_attributes') and el.param_attributes and len(el.param_attributes) > 0:
 
-    static constexpr std::array scParamAttributeKinds = {
-        % for attr in el.param_attributes:
-        ${IntrinsicFormatter.get_param_attributes_entry(attr, loop.last)}
-        % endfor
-    };
-    % endif
     % if hasattr(el, 'memory_effects'):
-
     static constexpr auto scMemoryEffects =
         ${IntrinsicFormatter.get_memory_effects_from_restrictions(el.memory_effects)};
     % endif

Original file line number	Diff line number	Diff line change
`@@ -75,19 +75,19 @@ namespace llvm`
`75`	`75`	`namespace GenISAIntrinsic`
`76`	`76`	`{`
`77`	`77`
`78`		`-std::string getName(ID id, ArrayRef<Type> OverloadedTys /= None/, ArrayRef<Type> OverloadedPointeeTys /= None/)`
	`78`	`+std::string getName(ID id, ArrayRef<Type> OverloadedTys /= None*/)`
`79`	`79`	`{`
`80`		`- return IGC::GetName(id, OverloadedTys, OverloadedPointeeTys);`
	`80`	`+ return IGC::GetName(id, OverloadedTys);`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`IntrinsicComments getIntrinsicComments(ID id)`
`84`	`84`	`{`
`85`	`85`	`return IGC::GetIntrinsicComments(id);`
`86`	`86`	`}`
`87`	`87`
`88`		`-Function* getDeclaration(Module* M, ID id, ArrayRef<Type> OverloadedTys /= None/, ArrayRef<Type> OverloadedPointeeTys /= None/)`
	`88`	`+Function* getDeclaration(Module* M, ID id, ArrayRef<Type> OverloadedTys /= None*/)`
`89`	`89`	`{`
`90`		`- return IGC::GetDeclaration(M, id, OverloadedTys, OverloadedPointeeTys);`
	`90`	`+ return IGC::GetDeclaration(M, id, OverloadedTys);`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`ID getIntrinsicID(const Function* F, bool useContextWrapper /= true/)`