[Sema] Allow implicit conversions of &overloaded_fn in C.
Also includes a minor ``enable_if`` docs update. Currently, our address-of overload machinery will only allow implicit conversions of overloaded functions to void* in C. For example: ``` void f(int) __attribute__((overloadable)); void f(double) __attribute__((overloadable, enable_if(0, ""))); void *fp = f; // OK. This is C and the target is void*. void (*fp2)(void) = f; // Error. This is C, but the target isn't void*. ``` This patch makes the assignment of `fp2` select the `f(int)` overload, rather than emitting an error (N.B. you'll still get a warning about the `fp2` assignment if you use -Wincompatible-pointer-types). Differential Revision: http://reviews.llvm.org/D13704 llvm-svn: 264132
This commit is contained in:
parent
a5b2972977
commit
6da4c20f7d
|
@ -260,6 +260,29 @@ only a single candidate. In a call to g(1, 1), the call is ambiguous even though
|
|||
not ODR-equivalent.
|
||||
|
||||
Query for this feature with ``__has_attribute(enable_if)``.
|
||||
|
||||
Note that functions with one or more ``enable_if`` attributes may not have
|
||||
their address taken, unless all of the conditions specified by said
|
||||
``enable_if`` are constants that evaluate to ``true``. For example:
|
||||
|
||||
.. code-block:: c
|
||||
|
||||
const int TrueConstant = 1;
|
||||
const int FalseConstant = 0;
|
||||
int f(int a) __attribute__((enable_if(a > 0, "")));
|
||||
int g(int a) __attribute__((enable_if(a == 0 || a != 0, "")));
|
||||
int h(int a) __attribute__((enable_if(1, "")));
|
||||
int i(int a) __attribute__((enable_if(TrueConstant, "")));
|
||||
int j(int a) __attribute__((enable_if(FalseConstant, "")));
|
||||
|
||||
void fn() {
|
||||
int (*ptr)(int);
|
||||
ptr = &f; // error: 'a > 0' is not always true
|
||||
ptr = &g; // error: 'a == 0 || a != 0' is not a truthy constant
|
||||
ptr = &h; // OK: 1 is a truthy constant
|
||||
ptr = &i; // OK: 'TrueConstant' is a truthy constant
|
||||
ptr = &j; // error: 'FalseConstant' is a constant, but not truthy
|
||||
}
|
||||
}];
|
||||
}
|
||||
|
||||
|
|
|
@ -8488,7 +8488,7 @@ Sema::AddArgumentDependentLookupCandidates(DeclarationName Name,
|
|||
// Cand1's first N enable_if attributes have precisely the same conditions as
|
||||
// Cand2's first N enable_if attributes (where N = the number of enable_if
|
||||
// attributes on Cand2), and Cand1 has more than N enable_if attributes.
|
||||
static bool hasBetterEnableIfAttrs(Sema &S, const FunctionDecl *Cand1,
|
||||
static bool hasBetterEnableIfAttrs(const Sema &S, const FunctionDecl *Cand1,
|
||||
const FunctionDecl *Cand2) {
|
||||
|
||||
// FIXME: The next several lines are just
|
||||
|
@ -10299,13 +10299,25 @@ public:
|
|||
bool hasComplained() const { return HasComplained; }
|
||||
|
||||
private:
|
||||
// Is A considered a better overload candidate for the desired type than B?
|
||||
bool isBetterCandidate(const FunctionDecl *A, const FunctionDecl *B) {
|
||||
return hasBetterEnableIfAttrs(S, A, B);
|
||||
bool candidateHasExactlyCorrectType(const FunctionDecl *FD) {
|
||||
QualType Discard;
|
||||
return Context.hasSameUnqualifiedType(TargetFunctionType, FD->getType()) ||
|
||||
S.IsNoReturnConversion(FD->getType(), TargetFunctionType, Discard);
|
||||
}
|
||||
|
||||
// Returns true if we've eliminated any (read: all but one) candidates, false
|
||||
// otherwise.
|
||||
/// \return true if A is considered a better overload candidate for the
|
||||
/// desired type than B.
|
||||
bool isBetterCandidate(const FunctionDecl *A, const FunctionDecl *B) {
|
||||
// If A doesn't have exactly the correct type, we don't want to classify it
|
||||
// as "better" than anything else. This way, the user is required to
|
||||
// disambiguate for us if there are multiple candidates and no exact match.
|
||||
return candidateHasExactlyCorrectType(A) &&
|
||||
(!candidateHasExactlyCorrectType(B) ||
|
||||
hasBetterEnableIfAttrs(S, A, B));
|
||||
}
|
||||
|
||||
/// \return true if we were able to eliminate all but one overload candidate,
|
||||
/// false otherwise.
|
||||
bool eliminiateSuboptimalOverloadCandidates() {
|
||||
// Same algorithm as overload resolution -- one pass to pick the "best",
|
||||
// another pass to be sure that nothing is better than the best.
|
||||
|
@ -10418,12 +10430,9 @@ private:
|
|||
if (!S.checkAddressOfFunctionIsAvailable(FunDecl))
|
||||
return false;
|
||||
|
||||
QualType ResultTy;
|
||||
if (Context.hasSameUnqualifiedType(TargetFunctionType,
|
||||
FunDecl->getType()) ||
|
||||
S.IsNoReturnConversion(FunDecl->getType(), TargetFunctionType,
|
||||
ResultTy) ||
|
||||
(!S.getLangOpts().CPlusPlus && TargetType->isVoidPointerType())) {
|
||||
// If we're in C, we need to support types that aren't exactly identical.
|
||||
if (!S.getLangOpts().CPlusPlus ||
|
||||
candidateHasExactlyCorrectType(FunDecl)) {
|
||||
Matches.push_back(std::make_pair(
|
||||
CurAccessFunPair, cast<FunctionDecl>(FunDecl->getCanonicalDecl())));
|
||||
FoundNonTemplateFunction = true;
|
||||
|
|
|
@ -29,3 +29,33 @@ int main() {
|
|||
cdv = f(cdv);
|
||||
vv = f(vv);
|
||||
}
|
||||
|
||||
// Ensuring that we pick the correct function for taking the address of an
|
||||
// overload when conversions are involved.
|
||||
|
||||
void addrof_many(int *a) __attribute__((overloadable, enable_if(0, "")));
|
||||
void addrof_many(void *a) __attribute__((overloadable));
|
||||
void addrof_many(char *a) __attribute__((overloadable));
|
||||
|
||||
void addrof_single(int *a) __attribute__((overloadable, enable_if(0, "")));
|
||||
void addrof_single(char *a) __attribute__((overloadable, enable_if(0, "")));
|
||||
void addrof_single(char *a) __attribute__((overloadable));
|
||||
|
||||
// CHECK-LABEL: define void @foo
|
||||
void foo() {
|
||||
// CHECK: store void (i8*)* @_Z11addrof_manyPc
|
||||
void (*p1)(char *) = &addrof_many;
|
||||
// CHECK: store void (i8*)* @_Z11addrof_manyPv
|
||||
void (*p2)(void *) = &addrof_many;
|
||||
// CHECK: void (i8*)* @_Z11addrof_manyPc
|
||||
void *vp1 = (void (*)(char *)) & addrof_many;
|
||||
// CHECK: void (i8*)* @_Z11addrof_manyPv
|
||||
void *vp2 = (void (*)(void *)) & addrof_many;
|
||||
|
||||
// CHECK: store void (i8*)* @_Z13addrof_singlePc
|
||||
void (*p3)(char *) = &addrof_single;
|
||||
// CHECK: @_Z13addrof_singlePc
|
||||
void (*p4)(int *) = &addrof_single;
|
||||
// CHECK: @_Z13addrof_singlePc
|
||||
void *vp3 = &addrof_single;
|
||||
}
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
// RUN: %clang_cc1 -fsyntax-only -verify %s
|
||||
// RUN: %clang_cc1 -fsyntax-only -verify %s -Wincompatible-pointer-types
|
||||
|
||||
int var __attribute__((overloadable)); // expected-error{{'overloadable' attribute only applies to functions}}
|
||||
void params(void) __attribute__((overloadable(12))); // expected-error {{'overloadable' attribute takes no arguments}}
|
||||
|
@ -99,3 +99,26 @@ void conversions() {
|
|||
unsigned char *c;
|
||||
multi_type(c);
|
||||
}
|
||||
|
||||
// Ensure that we allow C-specific type conversions in C
|
||||
void fn_type_conversions() {
|
||||
void foo(void *c) __attribute__((overloadable));
|
||||
void foo(char *c) __attribute__((overloadable));
|
||||
void (*ptr1)(void *) = &foo;
|
||||
void (*ptr2)(char *) = &foo;
|
||||
void (*ambiguous)(int *) = &foo; // expected-error{{initializing 'void (*)(int *)' with an expression of incompatible type '<overloaded function type>'}} expected-note@105{{candidate function}} expected-note@106{{candidate function}}
|
||||
void *vp_ambiguous = &foo; // expected-error{{initializing 'void *' with an expression of incompatible type '<overloaded function type>'}} expected-note@105{{candidate function}} expected-note@106{{candidate function}}
|
||||
|
||||
void (*specific1)(int *) = (void (*)(void *))&foo; // expected-warning{{incompatible pointer types initializing 'void (*)(int *)' with an expression of type 'void (*)(void *)'}}
|
||||
void *specific2 = (void (*)(void *))&foo;
|
||||
|
||||
void disabled(void *c) __attribute__((overloadable, enable_if(0, "")));
|
||||
void disabled(int *c) __attribute__((overloadable, enable_if(c, "")));
|
||||
void disabled(char *c) __attribute__((overloadable, enable_if(1, "The function name lies.")));
|
||||
// To be clear, these should all point to the last overload of 'disabled'
|
||||
void (*dptr1)(char *c) = &disabled;
|
||||
void (*dptr2)(void *c) = &disabled; // expected-warning{{incompatible pointer types initializing 'void (*)(void *)' with an expression of type '<overloaded function type>'}} expected-note@115{{candidate function made ineligible by enable_if}} expected-note@116{{candidate function made ineligible by enable_if}} expected-note@117{{candidate function has type mismatch at 1st parameter (expected 'void *' but has 'char *')}}
|
||||
void (*dptr3)(int *c) = &disabled; // expected-warning{{incompatible pointer types initializing 'void (*)(int *)' with an expression of type '<overloaded function type>'}} expected-note@115{{candidate function made ineligible by enable_if}} expected-note@116{{candidate function made ineligible by enable_if}} expected-note@117{{candidate function has type mismatch at 1st parameter (expected 'int *' but has 'char *')}}
|
||||
|
||||
void *specific_disabled = &disabled;
|
||||
}
|
||||
|
|
|
@ -38,8 +38,8 @@ void FunctionPtrs() {
|
|||
void (*p)(void *) = NotOverloaded; //expected-error{{cannot take address of function 'NotOverloaded' because parameter 1 has pass_object_size attribute}}
|
||||
void (*p2)(void *) = &NotOverloaded; //expected-error{{cannot take address of function 'NotOverloaded' because parameter 1 has pass_object_size attribute}}
|
||||
|
||||
void (*p3)(void *) = IsOverloaded; //expected-error{{initializing 'void (*)(void *)' with an expression of incompatible type '<overloaded function type>'}} expected-note@-6{{candidate address cannot be taken because parameter 1 has pass_object_size attribute}} expected-note@-5{{type mismatch}}
|
||||
void (*p4)(void *) = &IsOverloaded; //expected-error{{initializing 'void (*)(void *)' with an expression of incompatible type '<overloaded function type>'}} expected-note@-7{{candidate address cannot be taken because parameter 1 has pass_object_size attribute}} expected-note@-6{{type mismatch}}
|
||||
void (*p3)(void *) = IsOverloaded; //expected-warning{{incompatible pointer types initializing 'void (*)(void *)' with an expression of type '<overloaded function type>'}} expected-note@-6{{candidate address cannot be taken because parameter 1 has pass_object_size attribute}} expected-note@-5{{type mismatch}}
|
||||
void (*p4)(void *) = &IsOverloaded; //expected-warning{{incompatible pointer types initializing 'void (*)(void *)' with an expression of type '<overloaded function type>'}} expected-note@-7{{candidate address cannot be taken because parameter 1 has pass_object_size attribute}} expected-note@-6{{type mismatch}}
|
||||
|
||||
void (*p5)(char *) = IsOverloaded;
|
||||
void (*p6)(char *) = &IsOverloaded;
|
||||
|
|
Loading…
Reference in New Issue