1 // RUN: %clang_cc1 -triple i686-windows %s -fsyntax-only -Wno-unused-value -Wno-pointer-to-int-cast -Wmicrosoft -verify -fms-extensions
2 
3 struct A
4 {
5    int a[];  /* expected-warning {{flexible array member 'a' in otherwise empty struct is a Microsoft extension}} */
6 };
7 
8 struct PR28407
9 {
10   int : 1;
11   int a[]; /* expected-warning {{flexible array member 'a' in otherwise empty struct is a Microsoft extension}} */
12 };
13 
14 struct C {
15    int l;
16    union {
17        int c1[];   /* expected-warning {{flexible array member 'c1' in a union is a Microsoft extension}}  */
18        char c2[];  /* expected-warning {{flexible array member 'c2' in a union is a Microsoft extension}} */
19    };
20 };
21 
22 
23 struct D {
24    int l;
25    int D[];
26 };
27 
28 struct __declspec(uuid("00000000-0000-0000-C000-000000000046")) IUnknown {}; /* expected-error {{'uuid' attribute is not supported in C}} */
29 
30 [uuid("00000000-0000-0000-C000-000000000046")] struct IUnknown2 {}; /* expected-error {{'uuid' attribute is not supported in C}} */
31 
32 typedef struct notnested {
33   long bad1;
34   long bad2;
35 } NOTNESTED;
36 
37 
38 typedef struct nested1 {
39   long a;
40   struct notnested var1;
41   NOTNESTED var2;
42 } NESTED1;
43 
44 struct nested2 {
45   long b;
46   NESTED1;  // expected-warning {{anonymous structs are a Microsoft extension}}
47 };
48 
49 struct nested2 PR20573 = { .a = 3 };
50 
51 struct nested3 {
52   long d;
53   struct nested4 { // expected-warning {{anonymous structs are a Microsoft extension}}
54     long e;
55   };
56   union nested5 { // expected-warning {{anonymous unions are a Microsoft extension}}
57     long f;
58   };
59 };
60 
61 typedef union nested6 {
62   long f;
63 } NESTED6;
64 
65 struct test {
66   int c;
67   struct nested2;   // expected-warning {{anonymous structs are a Microsoft extension}}
68   NESTED6;   // expected-warning {{anonymous unions are a Microsoft extension}}
69 };
70 
foo()71 void foo()
72 {
73   struct test var;
74   var.a;
75   var.b;
76   var.c;
77   var.bad1;   // expected-error {{no member named 'bad1' in 'struct test'}}
78   var.bad2;   // expected-error {{no member named 'bad2' in 'struct test'}}
79 }
80 
81 // Enumeration types with a fixed underlying type.
82 const int seventeen = 17;
83 typedef int Int;
84 
85 struct X0 {
86   enum E1 : Int { SomeOtherValue } field;  // expected-warning{{enumeration types with a fixed underlying type are a Microsoft extension}}
87   enum E1 : seventeen;
88 };
89 
90 enum : long long {  // expected-warning{{enumeration types with a fixed underlying type are a Microsoft extension}}
91   SomeValue = 0x100000000
92 };
93 
pointer_to_integral_type_conv(char * ptr)94 void pointer_to_integral_type_conv(char* ptr) {
95   char ch = (char)ptr;
96   short sh = (short)ptr;
97   ch = (char)ptr;
98   sh = (short)ptr;
99 
100   // This is valid ISO C.
101   _Bool b = (_Bool)ptr;
102 }
103 
104 typedef struct {
105   UNKNOWN u; // expected-error {{unknown type name 'UNKNOWN'}}
106 } AA;
107 
108 typedef struct {
109   AA; // expected-warning {{anonymous structs are a Microsoft extension}}
110 } BB;
111 
112 struct anon_fault {
113   struct undefined; // expected-warning {{anonymous structs are a Microsoft extension}}
114                     // expected-error@-1 {{field has incomplete type 'struct undefined'}}
115                     // expected-note@-2 {{forward declaration of 'struct undefined'}}
116 };
117 
118 const int anon_falt_size = sizeof(struct anon_fault);
119 
120 __declspec(deprecated("This is deprecated")) enum DE1 { one, two } e1; // expected-note {{'e1' has been explicitly marked deprecated here}}
121 struct __declspec(deprecated) DS1 { int i; float f; }; // expected-note {{'DS1' has been explicitly marked deprecated here}}
122 
123 #define MY_TEXT		"This is also deprecated"
deprecated(MY_TEXT)124 __declspec(deprecated(MY_TEXT)) void Dfunc1( void ) {} // expected-note {{'Dfunc1' has been explicitly marked deprecated here}}
125 
126 struct __declspec(deprecated(123)) DS2 {};	// expected-error {{'deprecated' attribute requires a string}}
127 
test(void)128 void test( void ) {
129 	e1 = one;	// expected-warning {{'e1' is deprecated: This is deprecated}}
130 	struct DS1 s = { 0 };	// expected-warning {{'DS1' is deprecated}}
131 	Dfunc1();	// expected-warning {{'Dfunc1' is deprecated: This is also deprecated}}
132 
133 	enum DE1 no;	// no warning because E1 is not deprecated
134 }
135 
136 int __sptr wrong1; // expected-error {{'__sptr' attribute only applies to pointer arguments}}
137 // The modifier must follow the asterisk
138 int __sptr *wrong_psp; // expected-error {{'__sptr' attribute only applies to pointer arguments}}
139 int * __sptr __uptr wrong2; // expected-error {{'__sptr' and '__uptr' attributes are not compatible}}
140 int * __sptr __sptr wrong3; // expected-warning {{attribute '__sptr' is already applied}}
141 
142 // It is illegal to overload based on the type attribute.
ptr_func(int * __ptr32 i)143 void ptr_func(int * __ptr32 i) {}  // expected-note {{previous definition is here}}
ptr_func(int * __ptr64 i)144 void ptr_func(int * __ptr64 i) {} // expected-error {{redefinition of 'ptr_func'}}
145 
146 // It is also illegal to overload based on the pointer type attribute.
ptr_func2(int * __sptr __ptr32 i)147 void ptr_func2(int * __sptr __ptr32 i) {}  // expected-note {{previous definition is here}}
ptr_func2(int * __uptr __ptr32 i)148 void ptr_func2(int * __uptr __ptr32 i) {} // expected-error {{redefinition of 'ptr_func2'}}
149 
150 // Check for warning when return types have the type attribute.
ptr_func3()151 void *__ptr32 ptr_func3() { return 0; } // expected-note {{previous definition is here}}
ptr_func3()152 void *__ptr64 ptr_func3() { return 0; } // expected-error {{redefinition of 'ptr_func3'}}
153 
154 // Test that __ptr32/__ptr64 can be passed as arguments with other address
155 // spaces.
156 void ptr_func4(int *i);
157 void ptr_func5(int *__ptr32 i);
test_ptr_arguments()158 void test_ptr_arguments() {
159   int *__ptr64 i64;
160   ptr_func4(i64);
161   ptr_func5(i64);
162 }
163 
164 int * __sptr __ptr32 __sptr wrong4; // expected-warning {{attribute '__sptr' is already applied}}
165 
166 __ptr32 int *wrong5; // expected-error {{'__ptr32' attribute only applies to pointer arguments}}
167 
168 int *wrong6 __ptr32;  // expected-error {{expected ';' after top level declarator}} expected-warning {{declaration does not declare anything}}
169 
170 int * __ptr32 __ptr64 wrong7;  // expected-error {{'__ptr32' and '__ptr64' attributes are not compatible}}
171 
172 int * __ptr32 __ptr32 wrong8;	// expected-warning {{attribute '__ptr32' is already applied}}
173 
174 int *(__ptr32 __sptr wrong9); // expected-error {{'__sptr' attribute only applies to pointer arguments}} // expected-error {{'__ptr32' attribute only applies to pointer arguments}}
175 
176 typedef int *T;
177 T __ptr32 wrong10; // expected-error {{'__ptr32' attribute only applies to pointer arguments}}
178 
179 typedef char *my_va_list;
180 void __va_start(my_va_list *ap, ...); // expected-note {{passing argument to parameter 'ap' here}}
181 void vmyprintf(const char *f, my_va_list ap);
myprintf(const char * f,...)182 void myprintf(const char *f, ...) {
183   my_va_list ap;
184   if (1) {
185     __va_start(&ap, f);
186     vmyprintf(f, ap);
187     ap = 0;
188   } else {
189     __va_start(ap, f); // expected-warning {{incompatible pointer types passing 'my_va_list'}}
190   }
191 }
192 
193 // __unaligned handling
test_unaligned()194 void test_unaligned() {
195   __unaligned int *p1 = 0;
196   int *p2 = p1; // expected-warning {{initializing 'int *' with an expression of type '__unaligned int *' discards qualifiers}}
197   __unaligned int *p3 = p2;
198 }
199 
test_unaligned2(int x[__unaligned4])200 void test_unaligned2(int x[__unaligned 4]) {}
201 
202