1// RUN: %clang_cc1 -fsyntax-only -verify %s -Wincompatible-pointer-types 2 3int var __attribute__((overloadable)); // expected-error{{'overloadable' attribute only applies to functions}} 4void params(void) __attribute__((overloadable(12))); // expected-error {{'overloadable' attribute takes no arguments}} 5 6int *f(int) __attribute__((overloadable)); // expected-note 2{{previous overload of function is here}} 7float *f(float); // expected-error{{overloaded function 'f' must have the 'overloadable' attribute}} 8int *f(int); // expected-error{{redeclaration of 'f' must have the 'overloadable' attribute}} \ 9 // expected-note{{previous declaration is here}} 10double *f(double) __attribute__((overloadable)); // okay, new 11 12void test_f(int iv, float fv, double dv) { 13 int *ip = f(iv); 14 float *fp = f(fv); 15 double *dp = f(dv); 16} 17 18int *accept_funcptr(int (*)()) __attribute__((overloadable)); // \ 19 // expected-note{{candidate function}} 20float *accept_funcptr(int (*)(int, double)) __attribute__((overloadable)); // \ 21 // expected-note{{candidate function}} 22 23void test_funcptr(int (*f1)(int, double), 24 int (*f2)(int, float)) { 25 float *fp = accept_funcptr(f1); 26 accept_funcptr(f2); // expected-error{{no matching function for call to 'accept_funcptr'}} 27} 28 29struct X { int x; float y; }; 30struct Y { int x; float y; }; 31int* accept_struct(struct X x) __attribute__((__overloadable__)); 32float* accept_struct(struct Y y) __attribute__((overloadable)); 33 34void test_struct(struct X x, struct Y y) { 35 int *ip = accept_struct(x); 36 float *fp = accept_struct(y); 37} 38 39double *f(int) __attribute__((overloadable)); // expected-error{{conflicting types for 'f'}} 40 41double promote(float) __attribute__((__overloadable__)); // expected-note {{candidate}} 42double promote(double) __attribute__((__overloadable__)); // expected-note {{candidate}} 43long double promote(long double) __attribute__((__overloadable__)); // expected-note {{candidate}} 44 45void promote(...) __attribute__((__overloadable__, __unavailable__)); // \ 46 // expected-note{{candidate function}} 47 48void test_promote(short* sp) { 49 promote(1.0); 50 promote(sp); // expected-error{{call to unavailable function 'promote'}} 51} 52 53// PR6600 54typedef double Double; 55typedef Double DoubleVec __attribute__((vector_size(16))); 56typedef int Int; 57typedef Int IntVec __attribute__((vector_size(16))); 58double magnitude(DoubleVec) __attribute__((__overloadable__)); 59double magnitude(IntVec) __attribute__((__overloadable__)); 60double test_p6600(DoubleVec d) { 61 return magnitude(d) * magnitude(d); 62} 63 64// PR7738 65extern int __attribute__((overloadable)) f0(); // expected-error{{'overloadable' function 'f0' must have a prototype}} 66typedef int f1_type(); 67f1_type __attribute__((overloadable)) f1; // expected-error{{'overloadable' function 'f1' must have a prototype}} 68 69void test() { 70 f0(); 71 f1(); 72} 73 74void before_local_1(int) __attribute__((overloadable)); // expected-note {{here}} 75void before_local_2(int); // expected-note {{here}} 76void before_local_3(int) __attribute__((overloadable)); 77void local() { 78 void before_local_1(char); // expected-error {{must have the 'overloadable' attribute}} 79 void before_local_2(char) __attribute__((overloadable)); // expected-error {{conflicting types}} 80 void before_local_3(char) __attribute__((overloadable)); 81 void after_local_1(char); // expected-note {{here}} 82 void after_local_2(char) __attribute__((overloadable)); // expected-note {{here}} 83 void after_local_3(char) __attribute__((overloadable)); 84} 85void after_local_1(int) __attribute__((overloadable)); // expected-error {{conflicting types}} 86void after_local_2(int); // expected-error {{must have the 'overloadable' attribute}} 87void after_local_3(int) __attribute__((overloadable)); 88 89// Make sure we allow C-specific conversions in C. 90void conversions() { 91 void foo(char *c) __attribute__((overloadable)); 92 void foo(char *c) __attribute__((overloadable, enable_if(c, "nope.jpg"))); 93 94 void *ptr; 95 foo(ptr); 96 97 void multi_type(unsigned char *c) __attribute__((overloadable)); 98 void multi_type(signed char *c) __attribute__((overloadable)); 99 unsigned char *c; 100 multi_type(c); 101} 102 103// Ensure that we allow C-specific type conversions in C 104void fn_type_conversions() { 105 void foo(void *c) __attribute__((overloadable)); 106 void foo(char *c) __attribute__((overloadable)); 107 void (*ptr1)(void *) = &foo; 108 void (*ptr2)(char *) = &foo; 109 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}} 110 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}} 111 112 void (*specific1)(int *) = (void (*)(void *))&foo; // expected-warning{{incompatible pointer types initializing 'void (*)(int *)' with an expression of type 'void (*)(void *)'}} 113 void *specific2 = (void (*)(void *))&foo; 114 115 void disabled(void *c) __attribute__((overloadable, enable_if(0, ""))); 116 void disabled(int *c) __attribute__((overloadable, enable_if(c, ""))); 117 void disabled(char *c) __attribute__((overloadable, enable_if(1, "The function name lies."))); 118 // To be clear, these should all point to the last overload of 'disabled' 119 void (*dptr1)(char *c) = &disabled; 120 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 *')}} 121 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 *')}} 122 123 void *specific_disabled = &disabled; 124} 125