1 // RUN: %clang_cc1 -std=c++14 -triple i686-pc-win32 -fms-extensions -DMSABI -verify %s 2 // RUN: %clang_cc1 -std=c++14 -triple i686-pc-mingw32 -verify %s 3 // RUN: %clang_cc1 -std=c++14 -triple i686-pc-mingw32 -fms-extensions -verify %s 4 5 typedef void void_fun_t(); 6 typedef void __cdecl cdecl_fun_t(); 7 8 // Pointers to free functions 9 void free_func_default(); // expected-note 2 {{previous declaration is here}} 10 void __cdecl free_func_cdecl(); // expected-note 2 {{previous declaration is here}} 11 void __stdcall free_func_stdcall(); // expected-note 2 {{previous declaration is here}} 12 void __fastcall free_func_fastcall(); // expected-note 2 {{previous declaration is here}} 13 void __vectorcall free_func_vectorcall(); // expected-note 2 {{previous declaration is here}} 14 15 void __cdecl free_func_default(); 16 void __stdcall free_func_default(); // expected-error {{function declared 'stdcall' here was previously declared without calling convention}} 17 void __fastcall free_func_default(); // expected-error {{function declared 'fastcall' here was previously declared without calling convention}} 18 19 void free_func_cdecl(); 20 void __stdcall free_func_cdecl(); // expected-error {{function declared 'stdcall' here was previously declared 'cdecl'}} 21 void __fastcall free_func_cdecl(); // expected-error {{function declared 'fastcall' here was previously declared 'cdecl'}} 22 23 void free_func_stdcall(); 24 void __cdecl free_func_stdcall(); // expected-error {{function declared 'cdecl' here was previously declared 'stdcall'}} 25 void __fastcall free_func_stdcall(); // expected-error {{function declared 'fastcall' here was previously declared 'stdcall'}} 26 27 void __cdecl free_func_fastcall(); // expected-error {{function declared 'cdecl' here was previously declared 'fastcall'}} 28 void __stdcall free_func_fastcall(); // expected-error {{function declared 'stdcall' here was previously declared 'fastcall'}} 29 void free_func_fastcall(); 30 31 void __cdecl free_func_vectorcall(); // expected-error {{function declared 'cdecl' here was previously declared 'vectorcall'}} 32 void __stdcall free_func_vectorcall(); // expected-error {{function declared 'stdcall' here was previously declared 'vectorcall'}} 33 void free_func_vectorcall(); 34 35 // Overloaded functions may have different calling conventions 36 void __fastcall free_func_default(int); 37 void __cdecl free_func_default(int *); 38 39 void __thiscall free_func_cdecl(char *); 40 void __cdecl free_func_cdecl(double); 41 42 typedef void void_fun_t(); 43 typedef void __cdecl cdecl_fun_t(); 44 45 // Pointers to member functions 46 struct S { 47 void member_default1(); // expected-note {{previous declaration is here}} 48 void member_default2(); 49 void __cdecl member_cdecl1(); 50 void __cdecl member_cdecl2(); // expected-note {{previous declaration is here}} 51 void __thiscall member_thiscall1(); 52 void __thiscall member_thiscall2(); // expected-note {{previous declaration is here}} 53 void __vectorcall member_vectorcall1(); 54 void __vectorcall member_vectorcall2(); // expected-note {{previous declaration is here}} 55 56 // Typedefs carrying the __cdecl convention are adjusted to __thiscall. 57 void_fun_t member_typedef_default; // expected-note {{previous declaration is here}} 58 cdecl_fun_t member_typedef_cdecl1; // expected-note {{previous declaration is here}} 59 cdecl_fun_t __cdecl member_typedef_cdecl2; 60 void_fun_t __stdcall member_typedef_stdcall; 61 62 // Static member functions can't be __thiscall 63 static void static_member_default1(); 64 static void static_member_default2(); 65 static void static_member_default3(); // expected-note {{previous declaration is here}} 66 static void __cdecl static_member_cdecl1(); 67 static void __cdecl static_member_cdecl2(); // expected-note {{previous declaration is here}} 68 static void __stdcall static_member_stdcall1(); 69 static void __stdcall static_member_stdcall2(); 70 71 // Variadic functions can't be other than default or __cdecl 72 void member_variadic_default(int x, ...); 73 void __cdecl member_variadic_cdecl(int x, ...); 74 75 static void static_member_variadic_default(int x, ...); 76 static void __cdecl static_member_variadic_cdecl(int x, ...); 77 78 // Structors can't be other than default in MS ABI environment 79 #ifdef MSABI 80 __vectorcall S(); // expected-warning {{vectorcall calling convention ignored on constructor/destructor}} 81 #endif 82 }; 83 84 void __cdecl S::member_default1() {} // expected-error {{function declared 'cdecl' here was previously declared without calling convention}} 85 void __thiscall S::member_default2() {} 86 87 void __cdecl S::member_typedef_default() {} // expected-error {{function declared 'cdecl' here was previously declared without calling convention}} 88 void __cdecl S::member_typedef_cdecl1() {} // expected-error {{function declared 'cdecl' here was previously declared without calling convention}} 89 void __cdecl S::member_typedef_cdecl2() {} 90 void __stdcall S::member_typedef_stdcall() {} 91 92 void S::member_cdecl1() {} 93 void __thiscall S::member_cdecl2() {} // expected-error {{function declared 'thiscall' here was previously declared 'cdecl'}} 94 95 void S::member_thiscall1() {} 96 void __cdecl S::member_thiscall2() {} // expected-error {{function declared 'cdecl' here was previously declared 'thiscall'}} 97 98 void S::member_vectorcall1() {} 99 void __cdecl S::member_vectorcall2() {} // expected-error {{function declared 'cdecl' here was previously declared 'vectorcall'}} 100 101 void S::static_member_default1() {} 102 void __cdecl S::static_member_default2() {} 103 void __stdcall S::static_member_default3() {} // expected-error {{function declared 'stdcall' here was previously declared without calling convention}} 104 105 void S::static_member_cdecl1() {} 106 void __stdcall S::static_member_cdecl2() {} // expected-error {{function declared 'stdcall' here was previously declared 'cdecl'}} 107 108 void __cdecl S::member_variadic_default(int x, ...) { (void)x; } 109 void S::member_variadic_cdecl(int x, ...) { (void)x; } 110 111 void __cdecl S::static_member_variadic_default(int x, ...) { (void)x; } 112 void S::static_member_variadic_cdecl(int x, ...) { (void)x; } 113 114 // Declare a template using a calling convention. 115 template <class CharT> inline int __cdecl mystrlen(const CharT *str) { 116 int i; 117 for (i = 0; str[i]; i++) { } 118 return i; 119 } 120 extern int sse_strlen(const char *str); 121 template <> inline int __cdecl mystrlen(const char *str) { 122 return sse_strlen(str); 123 } 124 void use_tmpl(const char *str, const int *ints) { 125 mystrlen(str); 126 mystrlen(ints); 127 } 128 129 struct MixedCCStaticOverload { 130 static void overloaded(int a); 131 static void __stdcall overloaded(short a); 132 }; 133 134 void MixedCCStaticOverload::overloaded(int a) {} 135 void MixedCCStaticOverload::overloaded(short a) {} 136 137 // Friend function decls are cdecl by default, not thiscall. Friend method 138 // decls should always be redeclarations, because the class cannot be 139 // incomplete. 140 struct FriendClass { 141 void friend_method() {} 142 }; 143 void __stdcall friend_stdcall1() {} 144 class MakeFriendDecls { 145 int x; 146 friend void FriendClass::friend_method(); 147 friend void friend_default(); 148 friend void friend_stdcall1(); 149 friend void __stdcall friend_stdcall2(); 150 friend void friend_stdcall3(); // expected-note {{previous declaration is here}} 151 }; 152 void friend_default() {} 153 void __stdcall friend_stdcall3() {} // expected-error {{function declared 'stdcall' here was previously declared without calling convention}} 154 void __stdcall friend_stdcall2() {} 155 156 // Test functions with multiple attributes. 157 void __attribute__((noreturn)) __stdcall __attribute__((regparm(1))) multi_attribute(int x); 158 void multi_attribute(int x) { __builtin_unreachable(); } 159 160 161 // expected-error@+3 {{vectorcall and cdecl attributes are not compatible}} 162 // expected-error@+2 {{stdcall and cdecl attributes are not compatible}} 163 // expected-error@+1 {{fastcall and cdecl attributes are not compatible}} 164 void __cdecl __cdecl __stdcall __cdecl __fastcall __vectorcall multi_cc(int x); 165 166 template <typename T> void __stdcall StdcallTemplate(T) {} 167 template <> void StdcallTemplate<int>(int) {} 168 template <> void __stdcall StdcallTemplate<short>(short) {} 169 170 // FIXME: Note the template, not the implicit instantiation. 171 // expected-error@+2 {{function declared 'cdecl' here was previously declared 'stdcall}} 172 // expected-note@+1 {{previous declaration is here}} 173 template <> void __cdecl StdcallTemplate<long>(long) {} 174 175 struct ExactlyInt { 176 template <typename T> static int cast_to_int(T) { 177 return T::this_is_not_an_int(); 178 } 179 }; 180 template <> inline int ExactlyInt::cast_to_int<int>(int x) { return x; } 181 182 namespace test2 { 183 class foo { 184 template <typename T> void bar(T v); 185 }; 186 extern template void foo::bar(const void *); 187 } 188 189 namespace test3 { 190 struct foo { 191 typedef void bar(); 192 }; 193 bool zed(foo::bar *); 194 void bah() {} 195 void baz() { zed(bah); } 196 } 197 198 namespace test4 { 199 class foo { 200 template <typename T> static void bar(T v); 201 }; 202 extern template void foo::bar(const void *); 203 } 204 205 namespace test5 { 206 template <class T> 207 class valarray { 208 void bar(); 209 }; 210 extern template void valarray<int>::bar(); 211 } 212 213 namespace test6 { 214 struct foo { 215 int bar(); 216 }; 217 typedef int bar_t(); 218 void zed(bar_t foo::*) { 219 } 220 void baz() { 221 zed(&foo::bar); 222 } 223 } 224 225 namespace test7 { 226 template <typename T> 227 struct S { 228 void f(T t) { 229 t = 42; 230 } 231 }; 232 template<> void S<void*>::f(void*); 233 void g(S<void*> s, void* p) { 234 s.f(p); 235 } 236 } 237 238 namespace test8 { 239 template <typename T> 240 struct S { 241 void f(T t) { // expected-note {{previous declaration is here}} 242 t = 42; // expected-error {{assigning to 'void *' from incompatible type 'int'}} 243 } 244 }; 245 template<> void __cdecl S<void*>::f(void*); // expected-error {{function declared 'cdecl' here was previously declared without calling convention}} 246 void g(S<void*> s, void* p) { 247 s.f(p); // expected-note {{in instantiation of member function 'test8::S<void *>::f' requested here}} 248 } 249 } 250 251 namespace test9 { 252 // Used to fail when we forgot to make lambda call operators use __thiscall. 253 template <typename F> 254 decltype(auto) deduce(F f) { 255 return &decltype(f)::operator(); 256 } 257 template <typename C, typename R, typename A> 258 decltype(auto) signaturehelper(R (C::*f)(A) const) { 259 return R(); 260 } 261 void f() { 262 auto l = [](int x) { return x * 2; }; 263 decltype(signaturehelper(deduce(l))) p; 264 } 265 } 266
