202 lines
6.7 KiB
C
202 lines
6.7 KiB
C
// RUN: %clang_cc1 -triple i686-windows %s -fsyntax-only -Wno-unused-value -Wno-pointer-to-int-cast -Wmicrosoft -verify -fms-extensions
|
|
|
|
struct A
|
|
{
|
|
int a[]; /* expected-warning {{flexible array member 'a' in otherwise empty struct is a Microsoft extension}} */
|
|
};
|
|
|
|
struct PR28407
|
|
{
|
|
int : 1;
|
|
int a[]; /* expected-warning {{flexible array member 'a' in otherwise empty struct is a Microsoft extension}} */
|
|
};
|
|
|
|
struct C {
|
|
int l;
|
|
union {
|
|
int c1[]; /* expected-warning {{flexible array member 'c1' in a union is a Microsoft extension}} */
|
|
char c2[]; /* expected-warning {{flexible array member 'c2' in a union is a Microsoft extension}} */
|
|
};
|
|
};
|
|
|
|
|
|
struct D {
|
|
int l;
|
|
int D[];
|
|
};
|
|
|
|
struct __declspec(uuid("00000000-0000-0000-C000-000000000046")) IUnknown {}; /* expected-error {{'uuid' attribute is not supported in C}} */
|
|
|
|
[uuid("00000000-0000-0000-C000-000000000046")] struct IUnknown2 {}; /* expected-error {{'uuid' attribute is not supported in C}} */
|
|
|
|
typedef struct notnested {
|
|
long bad1;
|
|
long bad2;
|
|
} NOTNESTED;
|
|
|
|
|
|
typedef struct nested1 {
|
|
long a;
|
|
struct notnested var1;
|
|
NOTNESTED var2;
|
|
} NESTED1;
|
|
|
|
struct nested2 {
|
|
long b;
|
|
NESTED1; // expected-warning {{anonymous structs are a Microsoft extension}}
|
|
};
|
|
|
|
struct nested2 PR20573 = { .a = 3 };
|
|
|
|
struct nested3 {
|
|
long d;
|
|
struct nested4 { // expected-warning {{anonymous structs are a Microsoft extension}}
|
|
long e;
|
|
};
|
|
union nested5 { // expected-warning {{anonymous unions are a Microsoft extension}}
|
|
long f;
|
|
};
|
|
};
|
|
|
|
typedef union nested6 {
|
|
long f;
|
|
} NESTED6;
|
|
|
|
struct test {
|
|
int c;
|
|
struct nested2; // expected-warning {{anonymous structs are a Microsoft extension}}
|
|
NESTED6; // expected-warning {{anonymous unions are a Microsoft extension}}
|
|
};
|
|
|
|
void foo()
|
|
{
|
|
struct test var;
|
|
var.a;
|
|
var.b;
|
|
var.c;
|
|
var.bad1; // expected-error {{no member named 'bad1' in 'struct test'}}
|
|
var.bad2; // expected-error {{no member named 'bad2' in 'struct test'}}
|
|
}
|
|
|
|
// Enumeration types with a fixed underlying type.
|
|
const int seventeen = 17;
|
|
typedef int Int;
|
|
|
|
struct X0 {
|
|
enum E1 : Int { SomeOtherValue } field; // expected-warning{{enumeration types with a fixed underlying type are a Microsoft extension}}
|
|
enum E1 : seventeen;
|
|
};
|
|
|
|
enum : long long { // expected-warning{{enumeration types with a fixed underlying type are a Microsoft extension}}
|
|
SomeValue = 0x100000000
|
|
};
|
|
|
|
void pointer_to_integral_type_conv(char* ptr) {
|
|
char ch = (char)ptr;
|
|
short sh = (short)ptr;
|
|
ch = (char)ptr;
|
|
sh = (short)ptr;
|
|
|
|
// This is valid ISO C.
|
|
_Bool b = (_Bool)ptr;
|
|
}
|
|
|
|
typedef struct {
|
|
UNKNOWN u; // expected-error {{unknown type name 'UNKNOWN'}}
|
|
} AA;
|
|
|
|
typedef struct {
|
|
AA; // expected-warning {{anonymous structs are a Microsoft extension}}
|
|
} BB;
|
|
|
|
struct anon_fault {
|
|
struct undefined; // expected-warning {{anonymous structs are a Microsoft extension}}
|
|
// expected-error@-1 {{field has incomplete type 'struct undefined'}}
|
|
// expected-note@-2 {{forward declaration of 'struct undefined'}}
|
|
};
|
|
|
|
const int anon_falt_size = sizeof(struct anon_fault);
|
|
|
|
__declspec(deprecated("This is deprecated")) enum DE1 { one, two } e1; // expected-note {{'e1' has been explicitly marked deprecated here}}
|
|
struct __declspec(deprecated) DS1 { int i; float f; }; // expected-note {{'DS1' has been explicitly marked deprecated here}}
|
|
|
|
#define MY_TEXT "This is also deprecated"
|
|
__declspec(deprecated(MY_TEXT)) void Dfunc1( void ) {} // expected-note {{'Dfunc1' has been explicitly marked deprecated here}}
|
|
|
|
struct __declspec(deprecated(123)) DS2 {}; // expected-error {{'deprecated' attribute requires a string}}
|
|
|
|
void test( void ) {
|
|
e1 = one; // expected-warning {{'e1' is deprecated: This is deprecated}}
|
|
struct DS1 s = { 0 }; // expected-warning {{'DS1' is deprecated}}
|
|
Dfunc1(); // expected-warning {{'Dfunc1' is deprecated: This is also deprecated}}
|
|
|
|
enum DE1 no; // no warning because E1 is not deprecated
|
|
}
|
|
|
|
int __sptr wrong1; // expected-error {{'__sptr' attribute only applies to pointer arguments}}
|
|
// The modifier must follow the asterisk
|
|
int __sptr *wrong_psp; // expected-error {{'__sptr' attribute only applies to pointer arguments}}
|
|
int * __sptr __uptr wrong2; // expected-error {{'__sptr' and '__uptr' attributes are not compatible}}
|
|
int * __sptr __sptr wrong3; // expected-warning {{attribute '__sptr' is already applied}}
|
|
|
|
// It is illegal to overload based on the type attribute.
|
|
void ptr_func(int * __ptr32 i) {} // expected-note {{previous definition is here}}
|
|
void ptr_func(int * __ptr64 i) {} // expected-error {{redefinition of 'ptr_func'}}
|
|
|
|
// It is also illegal to overload based on the pointer type attribute.
|
|
void ptr_func2(int * __sptr __ptr32 i) {} // expected-note {{previous definition is here}}
|
|
void ptr_func2(int * __uptr __ptr32 i) {} // expected-error {{redefinition of 'ptr_func2'}}
|
|
|
|
// Check for warning when return types have the type attribute.
|
|
void *__ptr32 ptr_func3() { return 0; } // expected-note {{previous definition is here}}
|
|
void *__ptr64 ptr_func3() { return 0; } // expected-error {{redefinition of 'ptr_func3'}}
|
|
|
|
// Test that __ptr32/__ptr64 can be passed as arguments with other address
|
|
// spaces.
|
|
void ptr_func4(int *i);
|
|
void ptr_func5(int *__ptr32 i);
|
|
void test_ptr_arguments() {
|
|
int *__ptr64 i64;
|
|
ptr_func4(i64);
|
|
ptr_func5(i64);
|
|
}
|
|
|
|
int * __sptr __ptr32 __sptr wrong4; // expected-warning {{attribute '__sptr' is already applied}}
|
|
|
|
__ptr32 int *wrong5; // expected-error {{'__ptr32' attribute only applies to pointer arguments}}
|
|
|
|
int *wrong6 __ptr32; // expected-error {{expected ';' after top level declarator}} expected-warning {{declaration does not declare anything}}
|
|
|
|
int * __ptr32 __ptr64 wrong7; // expected-error {{'__ptr32' and '__ptr64' attributes are not compatible}}
|
|
|
|
int * __ptr32 __ptr32 wrong8; // expected-warning {{attribute '__ptr32' is already applied}}
|
|
|
|
int *(__ptr32 __sptr wrong9); // expected-error {{'__sptr' attribute only applies to pointer arguments}} // expected-error {{'__ptr32' attribute only applies to pointer arguments}}
|
|
|
|
typedef int *T;
|
|
T __ptr32 wrong10; // expected-error {{'__ptr32' attribute only applies to pointer arguments}}
|
|
|
|
typedef char *my_va_list;
|
|
void __va_start(my_va_list *ap, ...); // expected-note {{passing argument to parameter 'ap' here}}
|
|
void vmyprintf(const char *f, my_va_list ap);
|
|
void myprintf(const char *f, ...) {
|
|
my_va_list ap;
|
|
if (1) {
|
|
__va_start(&ap, f);
|
|
vmyprintf(f, ap);
|
|
ap = 0;
|
|
} else {
|
|
__va_start(ap, f); // expected-warning {{incompatible pointer types passing 'my_va_list'}}
|
|
}
|
|
}
|
|
|
|
// __unaligned handling
|
|
void test_unaligned() {
|
|
__unaligned int *p1 = 0;
|
|
int *p2 = p1; // expected-warning {{initializing 'int *' with an expression of type '__unaligned int *' discards qualifiers}}
|
|
__unaligned int *p3 = p2;
|
|
}
|
|
|
|
void test_unaligned2(int x[__unaligned 4]) {}
|
|
|