• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
member_default1()84 void __cdecl    S::member_default1() {} // expected-error {{function declared 'cdecl' here was previously declared without calling convention}}
member_default2()85 void __thiscall S::member_default2() {}
86 
member_typedef_default()87 void __cdecl   S::member_typedef_default() {} // expected-error {{function declared 'cdecl' here was previously declared without calling convention}}
member_typedef_cdecl1()88 void __cdecl   S::member_typedef_cdecl1() {} // expected-error {{function declared 'cdecl' here was previously declared without calling convention}}
member_typedef_cdecl2()89 void __cdecl   S::member_typedef_cdecl2() {}
member_typedef_stdcall()90 void __stdcall S::member_typedef_stdcall() {}
91 
member_cdecl1()92 void            S::member_cdecl1() {}
member_cdecl2()93 void __thiscall S::member_cdecl2() {} // expected-error {{function declared 'thiscall' here was previously declared 'cdecl'}}
94 
member_thiscall1()95 void            S::member_thiscall1() {}
member_thiscall2()96 void __cdecl    S::member_thiscall2() {} // expected-error {{function declared 'cdecl' here was previously declared 'thiscall'}}
97 
member_vectorcall1()98 void            S::member_vectorcall1() {}
member_vectorcall2()99 void __cdecl    S::member_vectorcall2() {} // expected-error {{function declared 'cdecl' here was previously declared 'vectorcall'}}
100 
static_member_default1()101 void            S::static_member_default1() {}
static_member_default2()102 void __cdecl    S::static_member_default2() {}
static_member_default3()103 void __stdcall  S::static_member_default3() {} // expected-error {{function declared 'stdcall' here was previously declared without calling convention}}
104 
static_member_cdecl1()105 void            S::static_member_cdecl1() {}
static_member_cdecl2()106 void __stdcall  S::static_member_cdecl2() {} // expected-error {{function declared 'stdcall' here was previously declared 'cdecl'}}
107 
member_variadic_default(int x,...)108 void __cdecl    S::member_variadic_default(int x, ...) { (void)x; }
member_variadic_cdecl(int x,...)109 void            S::member_variadic_cdecl(int x, ...) { (void)x; }
110 
static_member_variadic_default(int x,...)111 void __cdecl    S::static_member_variadic_default(int x, ...) { (void)x; }
static_member_variadic_cdecl(int x,...)112 void            S::static_member_variadic_cdecl(int x, ...) { (void)x; }
113 
114 // Declare a template using a calling convention.
mystrlen(const CharT * str)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);
mystrlen(const char * str)121 template <> inline int __cdecl mystrlen(const char *str) {
122   return sse_strlen(str);
123 }
use_tmpl(const char * str,const int * ints)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 
overloaded(int a)134 void MixedCCStaticOverload::overloaded(int a) {}
overloaded(short 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 {
friend_methodFriendClass141   void friend_method() {}
142 };
friend_stdcall1()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 };
friend_default()152 void           friend_default() {}
friend_stdcall3()153 void __stdcall friend_stdcall3() {} // expected-error {{function declared 'stdcall' here was previously declared without calling convention}}
friend_stdcall2()154 void __stdcall friend_stdcall2() {}
155 
156 // Test functions with multiple attributes.
157 void __attribute__((noreturn)) __stdcall __attribute__((regparm(1))) multi_attribute(int x);
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 
StdcallTemplate(T)166 template <typename T> void __stdcall StdcallTemplate(T) {}
StdcallTemplate(int)167 template <> void StdcallTemplate<int>(int) {}
StdcallTemplate(short)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}}
StdcallTemplate(long)173 template <> void __cdecl StdcallTemplate<long>(long) {}
174 
175 struct ExactlyInt {
cast_to_intExactlyInt176   template <typename T> static int cast_to_int(T) {
177     return T::this_is_not_an_int();
178   }
179 };
cast_to_int(int x)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 *);
bah()194   void bah() {}
baz()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();
zed(bar_t foo::*)218   void zed(bar_t foo::*) {
219   }
baz()220   void baz() {
221     zed(&foo::bar);
222   }
223 }
224 
225 namespace test7 {
226   template <typename T>
227   struct S {
ftest7::S228     void f(T t) {
229       t = 42;
230     }
231   };
232   template<> void S<void*>::f(void*);
g(S<void * > s,void * p)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 {
ftest8::S241     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}}
g(S<void * > s,void * p)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>
deduce(F f)254   decltype(auto) deduce(F f) {
255     return &decltype(f)::operator();
256   }
257   template <typename C, typename R, typename A>
signaturehelper(R (C::* f)(A)const)258   decltype(auto) signaturehelper(R (C::*f)(A) const) {
259     return R();
260   }
f()261   void f() {
262     auto l = [](int x) { return x * 2; };
263     decltype(signaturehelper(deduce(l))) p;
264   }
265 }
266