mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-19 11:35:51 -04:00
13ee62f7d7
Before this commit, we emit unavailable errors for calls to functions during overload resolution, and for references to all other declarations in DiagnoseUseOfDecl. The early checks during overload resolution aren't as good as the DiagnoseAvailabilityOfDecl based checks, as they error on the code from PR40991. This commit fixes this by removing the early checking. llvm.org/PR40991 rdar://48564179 Differential revision: https://reviews.llvm.org/D59394 llvm-svn: 356599
250 lines
12 KiB
C
250 lines
12 KiB
C
// 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}}
|
|
|
|
int *f(int) __attribute__((overloadable)); // expected-note{{previous overload of function is here}}
|
|
float *f(float);
|
|
int *f(int); // expected-error{{redeclaration of 'f' must have the 'overloadable' attribute}} \
|
|
// expected-note{{previous declaration is here}}
|
|
double *f(double) __attribute__((overloadable)); // okay, new
|
|
|
|
// Ensure we don't complain about overloadable on implicitly declared functions.
|
|
int isdigit(int) __attribute__((overloadable));
|
|
|
|
void test_f(int iv, float fv, double dv) {
|
|
int *ip = f(iv);
|
|
float *fp = f(fv);
|
|
double *dp = f(dv);
|
|
}
|
|
|
|
int *accept_funcptr(int (*)()) __attribute__((overloadable)); // \
|
|
// expected-note{{candidate function}}
|
|
float *accept_funcptr(int (*)(int, double)) __attribute__((overloadable)); // \
|
|
// expected-note{{candidate function}}
|
|
|
|
void test_funcptr(int (*f1)(int, double),
|
|
int (*f2)(int, float)) {
|
|
float *fp = accept_funcptr(f1);
|
|
accept_funcptr(f2); // expected-error{{call to 'accept_funcptr' is ambiguous}}
|
|
}
|
|
|
|
struct X { int x; float y; };
|
|
struct Y { int x; float y; };
|
|
int* accept_struct(struct X x) __attribute__((__overloadable__));
|
|
float* accept_struct(struct Y y) __attribute__((overloadable));
|
|
|
|
void test_struct(struct X x, struct Y y) {
|
|
int *ip = accept_struct(x);
|
|
float *fp = accept_struct(y);
|
|
}
|
|
|
|
double *f(int) __attribute__((overloadable)); // expected-error{{conflicting types for 'f'}}
|
|
|
|
double promote(float) __attribute__((__overloadable__));
|
|
double promote(double) __attribute__((__overloadable__));
|
|
long double promote(long double) __attribute__((__overloadable__));
|
|
|
|
void promote(...) __attribute__((__overloadable__, __unavailable__)); // expected-note {{marked unavailable here}}
|
|
|
|
void test_promote(short* sp) {
|
|
promote(1.0);
|
|
promote(sp); // expected-error{{'promote' is unavailable}}
|
|
}
|
|
|
|
// PR6600
|
|
typedef double Double;
|
|
typedef Double DoubleVec __attribute__((vector_size(16)));
|
|
typedef int Int;
|
|
typedef Int IntVec __attribute__((vector_size(16)));
|
|
double magnitude(DoubleVec) __attribute__((__overloadable__));
|
|
double magnitude(IntVec) __attribute__((__overloadable__));
|
|
double test_p6600(DoubleVec d) {
|
|
return magnitude(d) * magnitude(d);
|
|
}
|
|
|
|
// PR7738
|
|
extern int __attribute__((overloadable)) f0(); // expected-error{{'overloadable' function 'f0' must have a prototype}}
|
|
typedef int f1_type();
|
|
f1_type __attribute__((overloadable)) f1; // expected-error{{'overloadable' function 'f1' must have a prototype}}
|
|
|
|
void test() {
|
|
f0();
|
|
f1();
|
|
}
|
|
|
|
void before_local_1(int) __attribute__((overloadable));
|
|
void before_local_2(int); // expected-note {{here}}
|
|
void before_local_3(int) __attribute__((overloadable));
|
|
void local() {
|
|
void before_local_1(char);
|
|
void before_local_2(char); // expected-error {{conflicting types}}
|
|
void before_local_3(char) __attribute__((overloadable));
|
|
void after_local_1(char);
|
|
void after_local_2(char) __attribute__((overloadable));
|
|
void after_local_3(char) __attribute__((overloadable));
|
|
}
|
|
void after_local_1(int) __attribute__((overloadable));
|
|
void after_local_2(int);
|
|
void after_local_3(int) __attribute__((overloadable));
|
|
|
|
// Make sure we allow C-specific conversions in C.
|
|
void conversions() {
|
|
void foo(char *c) __attribute__((overloadable));
|
|
void foo(char *c) __attribute__((overloadable, enable_if(c, "nope.jpg")));
|
|
|
|
void *ptr;
|
|
foo(ptr);
|
|
|
|
void multi_type(unsigned char *c) __attribute__((overloadable));
|
|
void multi_type(signed char *c) __attribute__((overloadable));
|
|
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@-4{{candidate function}} expected-note@-3{{candidate function}}
|
|
void *vp_ambiguous = &foo; // expected-error{{initializing 'void *' with an expression of incompatible type '<overloaded function type>'}} expected-note@-5{{candidate function}} expected-note@-4{{candidate function}}
|
|
|
|
void (*specific1)(int *) = (void (*)(void *))&foo; // expected-warning{{incompatible function 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@-5{{candidate function made ineligible by enable_if}} expected-note@-4{{candidate function made ineligible by enable_if}} expected-note@-3{{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@-6{{candidate function made ineligible by enable_if}} expected-note@-5{{candidate function made ineligible by enable_if}} expected-note@-4{{candidate function has type mismatch at 1st parameter (expected 'int *' but has 'char *')}}
|
|
|
|
void *specific_disabled = &disabled;
|
|
}
|
|
|
|
void incompatible_pointer_type_conversions() {
|
|
char charbuf[1];
|
|
unsigned char ucharbuf[1];
|
|
int intbuf[1];
|
|
|
|
void foo(char *c) __attribute__((overloadable));
|
|
void foo(short *c) __attribute__((overloadable));
|
|
foo(charbuf);
|
|
foo(ucharbuf); // expected-error{{call to 'foo' is ambiguous}} expected-note@-3{{candidate function}} expected-note@-2{{candidate function}}
|
|
foo(intbuf); // expected-error{{call to 'foo' is ambiguous}} expected-note@-4{{candidate function}} expected-note@-3{{candidate function}}
|
|
|
|
void bar(unsigned char *c) __attribute__((overloadable));
|
|
void bar(signed char *c) __attribute__((overloadable));
|
|
bar(charbuf); // expected-error{{call to 'bar' is ambiguous}} expected-note@-2{{candidate function}} expected-note@-1{{candidate function}}
|
|
bar(ucharbuf);
|
|
bar(intbuf); // expected-error{{call to 'bar' is ambiguous}} expected-note@-4{{candidate function}} expected-note@-3{{candidate function}}
|
|
}
|
|
|
|
void dropping_qualifiers_is_incompatible() {
|
|
const char ccharbuf[1];
|
|
volatile char vcharbuf[1];
|
|
|
|
void foo(char *c) __attribute__((overloadable));
|
|
void foo(const volatile unsigned char *c) __attribute__((overloadable));
|
|
|
|
foo(ccharbuf); // expected-error{{call to 'foo' is ambiguous}} expected-note@-3{{candidate function}} expected-note@-2{{candidate function}}
|
|
foo(vcharbuf); // expected-error{{call to 'foo' is ambiguous}} expected-note@-4{{candidate function}} expected-note@-3{{candidate function}}
|
|
}
|
|
|
|
void overloadable_with_global() {
|
|
void wg_foo(void) __attribute__((overloadable)); // expected-note{{previous}}
|
|
void wg_foo(int) __attribute__((overloadable));
|
|
}
|
|
|
|
int wg_foo; // expected-error{{redefinition of 'wg_foo' as different kind of symbol}}
|
|
|
|
#if !__has_extension(overloadable_unmarked)
|
|
#error "We should have unmarked overload support"
|
|
#endif
|
|
|
|
void to_foo0(int);
|
|
void to_foo0(double) __attribute__((overloadable)); // expected-note{{previous overload}}
|
|
void to_foo0(int);
|
|
void to_foo0(double); // expected-error{{must have the 'overloadable' attribute}}
|
|
void to_foo0(int);
|
|
|
|
void to_foo1(int) __attribute__((overloadable)); // expected-note 2{{previous overload}}
|
|
void to_foo1(double);
|
|
void to_foo1(int); // expected-error{{must have the 'overloadable' attribute}}
|
|
void to_foo1(double);
|
|
void to_foo1(int); // expected-error{{must have the 'overloadable' attribute}}
|
|
|
|
void to_foo2(int); // expected-note{{previous unmarked overload}}
|
|
void to_foo2(double) __attribute__((overloadable)); // expected-note 2{{previous overload}}
|
|
void to_foo2(int) __attribute__((overloadable)); // expected-error {{must not have the 'overloadable' attribute}}
|
|
void to_foo2(double); // expected-error{{must have the 'overloadable' attribute}}
|
|
void to_foo2(int);
|
|
void to_foo2(double); // expected-error{{must have the 'overloadable' attribute}}
|
|
void to_foo2(int);
|
|
|
|
void to_foo3(int);
|
|
void to_foo3(double) __attribute__((overloadable)); // expected-note{{previous overload}}
|
|
void to_foo3(int);
|
|
void to_foo3(double); // expected-error{{must have the 'overloadable' attribute}}
|
|
|
|
void to_foo4(int) __attribute__((overloadable)); // expected-note{{previous overload}}
|
|
void to_foo4(int); // expected-error{{must have the 'overloadable' attribute}}
|
|
void to_foo4(double) __attribute__((overloadable));
|
|
|
|
void to_foo5(int);
|
|
void to_foo5(int); // expected-note 3{{previous unmarked overload}}
|
|
void to_foo5(float) __attribute__((overloadable));
|
|
void to_foo5(double); // expected-error{{at most one overload for a given name may lack the 'overloadable' attribute}}
|
|
void to_foo5(float) __attribute__((overloadable));
|
|
void to_foo5(short); // expected-error{{at most one overload for a given name may lack the 'overloadable' attribute}}
|
|
void to_foo5(long); // expected-error{{at most one overload for a given name may lack the 'overloadable' attribute}}
|
|
void to_foo5(double) __attribute__((overloadable));
|
|
|
|
void to_foo6(int) __attribute__((enable_if(1, ""), overloadable)); // expected-note{{previous overload}}
|
|
void to_foo6(int) __attribute__((enable_if(1, ""))); // expected-error{{must have the 'overloadable' attribute}}
|
|
void to_foo6(int) __attribute__((enable_if(1, ""), overloadable));
|
|
|
|
void to_foo7(int) __attribute__((enable_if(1, ""))); // expected-note{{previous unmarked overload}}
|
|
void to_foo7(int) __attribute__((enable_if(1, ""), overloadable)); // expected-error{{must not have the 'overloadable' attribute}}
|
|
void to_foo7(int) __attribute__((enable_if(1, "")));
|
|
|
|
void to_foo8(char *__attribute__((pass_object_size(0))))
|
|
__attribute__((enable_if(1, "")));
|
|
void to_foo8(char *__attribute__((pass_object_size(0))))
|
|
__attribute__((overloadable));
|
|
|
|
void to_foo9(int); // expected-note{{previous unmarked overload}}
|
|
// FIXME: It would be nice if we did better with the "previous unmarked
|
|
// overload" diag.
|
|
void to_foo9(int) __attribute__((overloadable)); // expected-error{{must not have the 'overloadable' attribute}} expected-note{{previous declaration}} expected-note{{previous unmarked overload}}
|
|
void to_foo9(float); // expected-error{{conflicting types for 'to_foo9'}}
|
|
void to_foo9(float) __attribute__((overloadable));
|
|
void to_foo9(double); // expected-error{{at most one overload for a given name may lack the 'overloadable' attribute}}
|
|
void to_foo9(double) __attribute__((overloadable));
|
|
|
|
void to_foo10(int) __attribute__((overloadable));
|
|
void to_foo10(double); // expected-note{{previous unmarked overload}}
|
|
// no "note: previous redecl" if no previous decl has `overloadable`
|
|
// spelled out
|
|
void to_foo10(float); // expected-error{{at most one overload for a given name may lack the 'overloadable' attribute}}
|
|
void to_foo10(float); // expected-error{{must have the 'overloadable' attribute}}
|
|
void to_foo10(float); // expected-error{{must have the 'overloadable' attribute}}
|
|
|
|
// Bug: we used to treat `__typeof__(foo)` as though it was `__typeof__(&foo)`
|
|
// if `foo` was overloaded with only one function that could have its address
|
|
// taken.
|
|
void typeof_function_is_not_a_pointer() {
|
|
void not_a_pointer(void *) __attribute__((overloadable));
|
|
void not_a_pointer(char *__attribute__((pass_object_size(1))))
|
|
__attribute__((overloadable));
|
|
|
|
__typeof__(not_a_pointer) *fn;
|
|
|
|
void take_fn(void (*)(void *));
|
|
// if take_fn is passed a void (**)(void *), we'll get a warning.
|
|
take_fn(fn);
|
|
}
|