Allow ifunc resolvers to accept arguments

[emaste]

Summary

When ifunc support was added to Clang (in rC265917) it did not allow resolvers to take function arguments. This was based on GCC's documentation, which states resolvers return a pointer and take no arguments.

However, GCC actually allows it, and glibc (on non-x86 platforms) and FreeBSD (on x86 and arm64) pass CPU identification information as arguments to ifunc resolvers. I believe GCC's documentation is simply incorrect / out-of-date.

We've removed the prohibition in FreeBSD's in-tree Clang: https://svnweb.freebsd.org/changeset/base/339019.

[jyknight]

Given that there's no technical reason for the compiler to prohibit this (it was just clang trying to diagnose a probable user-error, which turns out to not be as probable as ), this seems like the right solution to me.

[echristo]

SGTM.

include/clang/Basic/AttrDocs.td

string argument which is the message to display when emitting the warning.
   }];
 }
 
 def IFuncDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 ``__attribute__((ifunc("resolver")))`` is used to mark that the address of a declaration should be resolved at runtime by calling a resolver function.
 
-The symbol name of the resolver function is given in quotes.  A function with this name (after mangling) must be defined in the current translation unit; it may be ``static``.  The resolver function should take no arguments and return a pointer.
+The symbol name of the resolver function is given in quotes.  A function with this name (after mangling) must be defined in the current translation unit; it may be ``static``.  The resolver function should return a pointer.
 
 The ``ifunc`` attribute may only be used on a function declaration.  A function declaration with an ``ifunc`` attribute is considered to be a definition of the declared entity.  The entity must not have weak linkage; for example, in C++, it cannot be applied to a declaration if a definition at that location would be considered inline.
 
 Not all targets support this attribute. ELF target support depends on both the linker and runtime linker, and is available in at least lld 4.0 and later, binutils 2.20.1 and later, glibc v2.11.1 and later, and FreeBSD 9.1 and later. Non-ELF targets currently do not support this attribute.
   }];
 }
 
 def LTOVisibilityDocs : Documentation {

include/clang/Basic/DiagnosticSemaKinds.td

def warn_alias_with_section : Warning<
   "%select{alias|ifunc}1 will not be in section '%0' but in the same section as the %select{aliasee|resolver}2">,
   InGroup<IgnoredAttributes>;
 def err_duplicate_mangled_name : Error<
   "definition with same mangled name '%0' as another definition">;
 def err_cyclic_alias : Error<
   "%select{alias|ifunc}0 definition is part of a cycle">;
 def err_ifunc_resolver_return : Error<
   "ifunc resolver function must return a pointer">;
-def err_ifunc_resolver_params : Error<
-  "ifunc resolver function must have no parameters">;
 def warn_attribute_wrong_decl_type_str : Warning<
   "%0 attribute only applies to %1">, InGroup<IgnoredAttributes>;
 def err_attribute_wrong_decl_type_str : Error<
   warn_attribute_wrong_decl_type_str.Text>;
 def warn_attribute_wrong_decl_type : Warning<
   "%0 attribute only applies to %select{"
   "functions"
   "|unions"

lib/CodeGen/CodeGenModule.cpp

if (!GV) {
           << IsIFunc << IsIFunc;
     } else if (IsIFunc) {
       // Check resolver function type.
       llvm::FunctionType *FTy = dyn_cast<llvm::FunctionType>(
           GV->getType()->getPointerElementType());
       assert(FTy);
       if (!FTy->getReturnType()->isPointerTy())
         Diags.Report(Location, diag::err_ifunc_resolver_return);
-      if (FTy->getNumParams())
-        Diags.Report(Location, diag::err_ifunc_resolver_params);
     }
 
     llvm::Constant *Aliasee = Alias->getIndirectSymbol();
     llvm::GlobalValue *AliaseeGV;
     if (auto CE = dyn_cast<llvm::ConstantExpr>(Aliasee))
       AliaseeGV = cast<llvm::GlobalValue>(CE->getOperand(0));
     else
       AliaseeGV = cast<llvm::GlobalValue>(Aliasee);

test/Sema/attr-ifunc.c

 //expected-warning@-1 {{ifunc will always resolve to f3_c even if weak definition of f3_b is overridden}}
 void* f3_b() __attribute__((weak, alias("f3_c")));
 void* f3_c() { return 0; }
 
 void f4_ifunc() {}
 void f4() __attribute__((ifunc("f4_ifunc")));
 //expected-error@-1 {{ifunc resolver function must return a pointer}}
 
-void* f5_ifunc(int i) { return 0; }
-void f5() __attribute__((ifunc("f5_ifunc")));
-//expected-error@-1 {{ifunc resolver function must have no parameters}}
-
 #else
 void f1a() __asm("f1");
 void f1a() {}
 //expected-note@-1 {{previous definition is here}}
 void f1() __attribute__((ifunc("f1_ifunc")));
 //expected-error@-1 {{definition with same mangled name 'f1' as another definition}}
 void* f1_ifunc() { return 0; }
 
 void* f6_ifunc(int i);
 void __attribute__((ifunc("f6_ifunc"))) f6() {}
 //expected-error@-1 {{definition 'f6' cannot also be an ifunc}}
 
 #endif
 #endif