clang/test/Sema/MicrosoftExtensions.c

   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
  71 void foo(void)
  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
  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"
 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
 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.
 143 void ptr_func(int * __ptr32 i) {}  // expected-note {{previous definition is here}}
 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.
 147 void ptr_func2(int * __sptr __ptr32 i) {}  // expected-note {{previous definition is here}}
 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.
 151 void *__ptr32 ptr_func3(void) { return 0; } // expected-note {{previous definition is here}}
 152 void *__ptr64 ptr_func3(void) { 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);
 158 void test_ptr_arguments(void) {
 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);
 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
 194 void test_unaligned(void) {
 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
 200 void test_unaligned2(int x[__unaligned 4]) {}
 201