1 // RUN: %clang_cc1 -fsyntax-only -fdouble-square-bracket-attributes -verify %s -Wincompatible-pointer-types -Wno-strict-prototypes 2 3 int var __attribute__((overloadable)); // expected-error{{'overloadable' attribute only applies to functions}} 4 void bad_attr_target(int) [[clang::overloadable]]; // expected-error{{'overloadable' attribute cannot be applied to types}} 5 void params(void) __attribute__((overloadable(12))); // expected-error {{'overloadable' attribute takes no arguments}} 6 7 int *f(int) __attribute__((overloadable)); // expected-note{{previous overload of function is here}} 8 float *f(float); 9 int *f(int); // expected-error{{redeclaration of 'f' must have the 'overloadable' attribute}} \ 10 // expected-note{{previous declaration is here}} 11 double *f(double) __attribute__((overloadable)); // okay, new 12 13 // Ensure we don't complain about overloadable on implicitly declared functions. 14 int isdigit(int) __attribute__((overloadable)); 15 16 void test_f(int iv, float fv, double dv) { 17 int *ip = f(iv); 18 float *fp = f(fv); 19 double *dp = f(dv); 20 } 21 22 int *accept_funcptr(int (*)()) __attribute__((overloadable)); // \ 23 // expected-note{{candidate function}} 24 float *accept_funcptr(int (*)(int, double)) __attribute__((overloadable)); // \ 25 // expected-note{{candidate function}} 26 27 void test_funcptr(int (*f1)(int, double), 28 int (*f2)(int, float)) { 29 float *fp = accept_funcptr(f1); 30 accept_funcptr(f2); // expected-error{{no matching function for call to 'accept_funcptr'}} 31 } 32 33 struct X { int x; float y; }; 34 struct Y { int x; float y; }; 35 int* accept_struct(struct X x) __attribute__((__overloadable__)); 36 float* accept_struct(struct Y y) __attribute__((overloadable)); 37 38 void test_struct(struct X x, struct Y y) { 39 int *ip = accept_struct(x); 40 float *fp = accept_struct(y); 41 } 42 43 double *f(int) __attribute__((overloadable)); // expected-error{{conflicting types for 'f'}} 44 45 double promote(float) __attribute__((__overloadable__)); 46 double promote(double) __attribute__((__overloadable__)); 47 long double promote(long double) __attribute__((__overloadable__)); 48 49 void promote(...) __attribute__((__overloadable__, __unavailable__)); // expected-note {{marked unavailable here}} 50 51 void test_promote(short* sp) { 52 promote(1.0); 53 promote(sp); // expected-error{{'promote' is unavailable}} 54 } 55 56 // PR6600 57 typedef double Double; 58 typedef Double DoubleVec __attribute__((vector_size(16))); 59 typedef int Int; 60 typedef Int IntVec __attribute__((vector_size(16))); 61 double magnitude(DoubleVec) __attribute__((__overloadable__)); 62 double magnitude(IntVec) __attribute__((__overloadable__)); 63 double test_p6600(DoubleVec d) { 64 return magnitude(d) * magnitude(d); 65 } 66 67 // PR7738 68 extern int __attribute__((overloadable)) f0(); // expected-error{{'overloadable' function 'f0' must have a prototype}} 69 typedef int f1_type(); 70 f1_type __attribute__((overloadable)) f1; // expected-error{{'overloadable' function 'f1' must have a prototype}} 71 72 void test() { 73 f0(); 74 f1(); 75 } 76 77 // Validate that the invalid function doesn't stay overloadable. 78 int __attribute__((overloadable)) invalid(); // expected-error{{'overloadable' function 'invalid' must have a prototype}} 79 int __attribute__((overloadable)) invalid(int); // expected-error{{redeclaration of 'invalid' must not have the 'overloadable' attribute}} 80 // expected-note@-2{{previous unmarked overload of function is here}} 81 void use_invalid(void) { 82 invalid(); // expected-error{{too few arguments to function call, expected 1, have 0}} 83 // expected-note@-4{{'invalid' declared here}} 84 invalid(1); 85 } 86 87 void before_local_1(int) __attribute__((overloadable)); 88 void before_local_2(int); // expected-note {{here}} 89 void before_local_3(int) __attribute__((overloadable)); 90 void local() { 91 void before_local_1(char); 92 void before_local_2(char); // expected-error {{conflicting types}} 93 void before_local_3(char) __attribute__((overloadable)); 94 void after_local_1(char); 95 void after_local_2(char) __attribute__((overloadable)); 96 void after_local_3(char) __attribute__((overloadable)); 97 } 98 void after_local_1(int) __attribute__((overloadable)); 99 void after_local_2(int); 100 void after_local_3(int) __attribute__((overloadable)); 101 102 // Make sure we allow C-specific conversions in C. 103 void conversions() { 104 void foo(char *c) __attribute__((overloadable)); 105 void foo(char *c) __attribute__((overloadable, enable_if(c, "nope.jpg"))); 106 107 void *ptr; 108 foo(ptr); 109 110 void multi_type(unsigned char *c) __attribute__((overloadable)); 111 void multi_type(signed char *c) __attribute__((overloadable)); 112 unsigned char *c; 113 multi_type(c); 114 } 115 116 // Ensure that we allow C-specific type conversions in C 117 void fn_type_conversions() { 118 void foo(void *c) __attribute__((overloadable)); 119 void foo(char *c) __attribute__((overloadable)); 120 void (*ptr1)(void *) = &foo; 121 void (*ptr2)(char *) = &foo; 122 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}} 123 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}} 124 125 void (*specific1)(int *) = (void (*)(void *))&foo; // expected-error{{incompatible function pointer types initializing 'void (*)(int *)' with an expression of type 'void (*)(void *)'}} 126 void *specific2 = (void (*)(void *))&foo; 127 128 void disabled(void *c) __attribute__((overloadable, enable_if(0, ""))); 129 void disabled(int *c) __attribute__((overloadable, enable_if(c, ""))); 130 void disabled(char *c) __attribute__((overloadable, enable_if(1, "The function name lies."))); 131 // To be clear, these should all point to the last overload of 'disabled' 132 void (*dptr1)(char *c) = &disabled; 133 void (*dptr2)(void *c) = &disabled; // expected-error{{incompatible function 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 *')}} 134 void (*dptr3)(int *c) = &disabled; // expected-error{{incompatible function 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 *')}} 135 136 void *specific_disabled = &disabled; 137 } 138 139 void incompatible_pointer_type_conversions() { 140 char charbuf[1]; 141 unsigned char ucharbuf[1]; 142 int intbuf[1]; 143 144 void foo(char *c) __attribute__((overloadable)); 145 void foo(short *c) __attribute__((overloadable)); 146 foo(charbuf); 147 foo(ucharbuf); // expected-error{{call to 'foo' is ambiguous}} expected-note@-3{{candidate function}} expected-note@-2{{candidate function}} 148 foo(intbuf); // expected-error{{call to 'foo' is ambiguous}} expected-note@-4{{candidate function}} expected-note@-3{{candidate function}} 149 150 void bar(unsigned char *c) __attribute__((overloadable)); 151 void bar(signed char *c) __attribute__((overloadable)); 152 bar(charbuf); // expected-error{{call to 'bar' is ambiguous}} expected-note@-2{{candidate function}} expected-note@-1{{candidate function}} 153 bar(ucharbuf); 154 bar(intbuf); // expected-error{{call to 'bar' is ambiguous}} expected-note@-4{{candidate function}} expected-note@-3{{candidate function}} 155 } 156 157 void dropping_qualifiers_is_incompatible() { 158 const char ccharbuf[1]; 159 volatile char vcharbuf[1]; 160 161 void foo(char *c) __attribute__((overloadable)); 162 void foo(const volatile unsigned char *c) __attribute__((overloadable)); 163 164 foo(ccharbuf); // expected-error{{call to 'foo' is ambiguous}} expected-note@-3{{candidate function}} expected-note@-2{{candidate function}} 165 foo(vcharbuf); // expected-error{{call to 'foo' is ambiguous}} expected-note@-4{{candidate function}} expected-note@-3{{candidate function}} 166 } 167 168 void overloadable_with_global() { 169 void wg_foo(void) __attribute__((overloadable)); // expected-note{{previous}} 170 void wg_foo(int) __attribute__((overloadable)); 171 } 172 173 int wg_foo; // expected-error{{redefinition of 'wg_foo' as different kind of symbol}} 174 175 #if !__has_extension(overloadable_unmarked) 176 #error "We should have unmarked overload support" 177 #endif 178 179 void to_foo0(int); 180 void to_foo0(double) __attribute__((overloadable)); // expected-note{{previous overload}} 181 void to_foo0(int); 182 void to_foo0(double); // expected-error{{must have the 'overloadable' attribute}} 183 void to_foo0(int); 184 185 void to_foo1(int) __attribute__((overloadable)); // expected-note 2{{previous overload}} 186 void to_foo1(double); 187 void to_foo1(int); // expected-error{{must have the 'overloadable' attribute}} 188 void to_foo1(double); 189 void to_foo1(int); // expected-error{{must have the 'overloadable' attribute}} 190 191 void to_foo2(int); // expected-note{{previous unmarked overload}} 192 void to_foo2(double) __attribute__((overloadable)); // expected-note 2{{previous overload}} 193 void to_foo2(int) __attribute__((overloadable)); // expected-error {{must not have the 'overloadable' attribute}} 194 void to_foo2(double); // expected-error{{must have the 'overloadable' attribute}} 195 void to_foo2(int); 196 void to_foo2(double); // expected-error{{must have the 'overloadable' attribute}} 197 void to_foo2(int); 198 199 void to_foo3(int); 200 void to_foo3(double) __attribute__((overloadable)); // expected-note{{previous overload}} 201 void to_foo3(int); 202 void to_foo3(double); // expected-error{{must have the 'overloadable' attribute}} 203 204 void to_foo4(int) __attribute__((overloadable)); // expected-note{{previous overload}} 205 void to_foo4(int); // expected-error{{must have the 'overloadable' attribute}} 206 void to_foo4(double) __attribute__((overloadable)); 207 208 void to_foo5(int); 209 void to_foo5(int); // expected-note 3{{previous unmarked overload}} 210 void to_foo5(float) __attribute__((overloadable)); 211 void to_foo5(double); // expected-error{{at most one overload for a given name may lack the 'overloadable' attribute}} 212 void to_foo5(float) __attribute__((overloadable)); 213 void to_foo5(short); // expected-error{{at most one overload for a given name may lack the 'overloadable' attribute}} 214 void to_foo5(long); // expected-error{{at most one overload for a given name may lack the 'overloadable' attribute}} 215 void to_foo5(double) __attribute__((overloadable)); 216 217 void to_foo6(int) __attribute__((enable_if(1, ""), overloadable)); // expected-note{{previous overload}} 218 void to_foo6(int) __attribute__((enable_if(1, ""))); // expected-error{{must have the 'overloadable' attribute}} 219 void to_foo6(int) __attribute__((enable_if(1, ""), overloadable)); 220 221 void to_foo7(int) __attribute__((enable_if(1, ""))); // expected-note{{previous unmarked overload}} 222 void to_foo7(int) __attribute__((enable_if(1, ""), overloadable)); // expected-error{{must not have the 'overloadable' attribute}} 223 void to_foo7(int) __attribute__((enable_if(1, ""))); 224 225 void to_foo8(char *__attribute__((pass_object_size(0)))) 226 __attribute__((enable_if(1, ""))); 227 void to_foo8(char *__attribute__((pass_object_size(0)))) 228 __attribute__((overloadable)); 229 230 void to_foo9(int); // expected-note{{previous unmarked overload}} 231 // FIXME: It would be nice if we did better with the "previous unmarked 232 // overload" diag. 233 void to_foo9(int) __attribute__((overloadable)); // expected-error{{must not have the 'overloadable' attribute}} expected-note{{previous declaration}} expected-note{{previous unmarked overload}} 234 void to_foo9(float); // expected-error{{conflicting types for 'to_foo9'}} 235 void to_foo9(float) __attribute__((overloadable)); 236 void to_foo9(double); // expected-error{{at most one overload for a given name may lack the 'overloadable' attribute}} 237 void to_foo9(double) __attribute__((overloadable)); 238 239 void to_foo10(int) __attribute__((overloadable)); 240 void to_foo10(double); // expected-note{{previous unmarked overload}} 241 // no "note: previous redecl" if no previous decl has `overloadable` 242 // spelled out 243 void to_foo10(float); // expected-error{{at most one overload for a given name may lack the 'overloadable' attribute}} 244 void to_foo10(float); // expected-error{{must have the 'overloadable' attribute}} 245 void to_foo10(float); // expected-error{{must have the 'overloadable' attribute}} 246 247 // Bug: we used to treat `__typeof__(foo)` as though it was `__typeof__(&foo)` 248 // if `foo` was overloaded with only one function that could have its address 249 // taken. 250 void typeof_function_is_not_a_pointer() { 251 void not_a_pointer(void *) __attribute__((overloadable)); 252 void not_a_pointer(char *__attribute__((pass_object_size(1)))) 253 __attribute__((overloadable)); 254 255 __typeof__(not_a_pointer) *fn; 256 257 void take_fn(void (*)(void *)); 258 // if take_fn is passed a void (**)(void *), we'll get a warning. 259 take_fn(fn); 260 } 261 262 // PR53805 263 // We previously failed to consider the attribute being written before the 264 // declaration when considering whether to allow a variadic signature with no 265 // other parameters, and so we handled these cases differently. 266 __attribute__((overloadable)) void can_overload_1(...); // ok, was previously rejected 267 void can_overload_2(...) __attribute__((overloadable)); // ok 268 [[clang::overloadable]] void can_overload_3(...); // ok, was previously rejected 269 void can_overload_4 [[clang::overloadable]] (...); // ok 270 void cannot_overload(...) [[clang::overloadable]]; // expected-error {{ISO C requires a named parameter before '...'}} \ 271 // expected-error {{'overloadable' attribute cannot be applied to types}} 272