diff options
Diffstat (limited to 'clang/test/Sema')
309 files changed, 16526 insertions, 0 deletions
diff --git a/clang/test/Sema/128bitint.c b/clang/test/Sema/128bitint.c new file mode 100644 index 0000000..89d3ee2 --- /dev/null +++ b/clang/test/Sema/128bitint.c @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-apple-darwin9 %s +typedef int i128 __attribute__((__mode__(TI))); +typedef unsigned u128 __attribute__((__mode__(TI))); + +int a[((i128)-1 ^ (i128)-2) == 1 ? 1 : -1]; +int a[(u128)-1 > 1LL ? 1 : -1]; + +// PR5435 +__uint128_t b = (__uint128_t)-1; + +// PR11916: Support for libstdc++ 4.7 +__int128 i = (__int128)0; +unsigned __int128 u = (unsigned __int128)-1; diff --git a/clang/test/Sema/2007-10-01-BuildArrayRef.c b/clang/test/Sema/2007-10-01-BuildArrayRef.c new file mode 100644 index 0000000..4692731 --- /dev/null +++ b/clang/test/Sema/2007-10-01-BuildArrayRef.c @@ -0,0 +1,20 @@ +// RUN: not %clang_cc1_only -c %s -o - > /dev/null +// PR 1603 +void func() +{ + const int *arr; + arr[0] = 1; // expected-error {{assignment of read-only location}} +} + +struct foo { + int bar; +}; +struct foo sfoo = { 0 }; + +int func2() +{ + const struct foo *fp; + fp = &sfoo; + fp[0].bar = 1; // expected-error {{ assignment of read-only member}} + return sfoo.bar; +} diff --git a/clang/test/Sema/2009-03-09-WeakDeclarations-1.c b/clang/test/Sema/2009-03-09-WeakDeclarations-1.c new file mode 100644 index 0000000..f219de6 --- /dev/null +++ b/clang/test/Sema/2009-03-09-WeakDeclarations-1.c @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 %s -triple i686-apple-darwin +// Insist upon warnings for inappropriate weak attributes. + +// O.K. +extern int ext_weak_import __attribute__ ((__weak_import__)); + +// These are inappropriate, and should generate warnings: +int decl_weak_import __attribute__ ((__weak_import__)); // expected-warning {'weak_import' attribute cannot be specified on a definition} +int decl_initialized_weak_import __attribute__ ((__weak_import__)) = 13; // expected-warning {'weak_import' attribute cannot be specified on a definition} + +// O.K. +extern int ext_f(void) __attribute__ ((__weak_import__)); + +// These are inappropriate, and should generate warnings: +int def_f(void) __attribute__ ((__weak_import__)); +int __attribute__ ((__weak_import__)) decl_f(void) {return 0;}; diff --git a/clang/test/Sema/2009-04-22-UnknownSize.c b/clang/test/Sema/2009-04-22-UnknownSize.c new file mode 100644 index 0000000..9f71740 --- /dev/null +++ b/clang/test/Sema/2009-04-22-UnknownSize.c @@ -0,0 +1,4 @@ +// RUN: not %clang_cc1 %s -emit-llvm -o - +// PR2958 +static struct foo s; // expected-error { tentative definition has type 'struct foo' that is never completed } +struct foo *p = &s; diff --git a/clang/test/Sema/2009-07-17-VoidParameter.c b/clang/test/Sema/2009-07-17-VoidParameter.c new file mode 100644 index 0000000..68d1b1e --- /dev/null +++ b/clang/test/Sema/2009-07-17-VoidParameter.c @@ -0,0 +1,4 @@ +// RUN: not %clang_cc1 -emit-llvm %s -o - +// PR4214 +typedef void vt; +void (*func_ptr)(vt my_vt); // expected-error {argument may not have 'void' type} diff --git a/clang/test/Sema/2010-05-31-palignr.c b/clang/test/Sema/2010-05-31-palignr.c new file mode 100644 index 0000000..12be29a --- /dev/null +++ b/clang/test/Sema/2010-05-31-palignr.c @@ -0,0 +1,22 @@ +// RUN: not %clang_cc1 -triple x86_64-apple-darwin -emit-llvm -o /dev/null %s + +#include <tmmintrin.h> + +extern int i; + +int main () +{ +#if defined( __SSSE3__ ) + + typedef int16_t vSInt16 __attribute__ ((__vector_size__ (16))); + + short dtbl[] = {1,2,3,4,5,6,7,8}; + vSInt16 *vdtbl = (vSInt16*) dtbl; + + vSInt16 v0; + v0 = *vdtbl; + v0 = _mm_alignr_epi8(v0, v0, i); // expected-error {{argument to '__builtin_ia32_palignr128' must be a constant integer}} + + return 0; +#endif +} diff --git a/clang/test/Sema/Inputs/conversion.h b/clang/test/Sema/Inputs/conversion.h new file mode 100644 index 0000000..768190f --- /dev/null +++ b/clang/test/Sema/Inputs/conversion.h @@ -0,0 +1,4 @@ +/* Fake system header for Sema/conversion.c */ + +#define LONG_MAX __LONG_MAX__ +#define SETBIT(set,bit) do { int i = bit; set[i/(8*sizeof(set[0]))] |= (1 << (i%(8*sizeof(set)))); } while(0) diff --git a/clang/test/Sema/Inputs/pragma-arc-cf-code-audited.h b/clang/test/Sema/Inputs/pragma-arc-cf-code-audited.h new file mode 100644 index 0000000..6ea360c --- /dev/null +++ b/clang/test/Sema/Inputs/pragma-arc-cf-code-audited.h @@ -0,0 +1,16 @@ + + + + + + + + + + + + + + + +#pragma clang arc_cf_code_audited begin diff --git a/clang/test/Sema/Inputs/unused-expr-system-header.h b/clang/test/Sema/Inputs/unused-expr-system-header.h new file mode 100644 index 0000000..72b2d95 --- /dev/null +++ b/clang/test/Sema/Inputs/unused-expr-system-header.h @@ -0,0 +1,23 @@ +// "System header" for testing that -Wunused-value is properly suppressed in +// certain cases. + +#define POSSIBLY_BAD_MACRO(x) \ + { int i = x; \ + i; } + +#define STATEMENT_EXPR_MACRO(x) \ + (__extension__ \ + ({int i = x; \ + i;})) + +#define COMMA_MACRO_1(x, y) \ + {x, y;} + +#define COMMA_MACRO_2(x, y) \ + if (x) { 1 == 2, y; } + +#define COMMA_MACRO_3(x, y) \ + (x, y) + +#define COMMA_MACRO_4(x, y) \ + ( 1 == 2, y ) diff --git a/clang/test/Sema/MicrosoftCompatibility.c b/clang/test/Sema/MicrosoftCompatibility.c new file mode 100644 index 0000000..f148e86 --- /dev/null +++ b/clang/test/Sema/MicrosoftCompatibility.c @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 %s -fsyntax-only -Wno-unused-value -Wmicrosoft -verify -fms-compatibility + +enum ENUM1; // expected-warning {{forward references to 'enum' types are a Microsoft extension}} +enum ENUM1 var1 = 3; +enum ENUM1* var2 = 0; + + +enum ENUM2 { + ENUM2_a = (enum ENUM2) 4, + ENUM2_b = 0x9FFFFFFF, // expected-warning {{enumerator value is not representable in the underlying type 'int'}} + ENUM2_c = 0x100000000 // expected-warning {{enumerator value is not representable in the underlying type 'int'}} +}; + +__declspec(noreturn) void f6( void ) { + return; // expected-warning {{function 'f6' declared 'noreturn' should not return}} +} diff --git a/clang/test/Sema/MicrosoftExtensions.c b/clang/test/Sema/MicrosoftExtensions.c new file mode 100644 index 0000000..fb0c6bd --- /dev/null +++ b/clang/test/Sema/MicrosoftExtensions.c @@ -0,0 +1,102 @@ +// RUN: %clang_cc1 %s -fsyntax-only -Wno-unused-value -Wmicrosoft -verify -fms-extensions + + +struct A +{ + 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[]; +}; + + + + + + +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 test { + int c; + struct nested2; // expected-warning {{anonymous structs 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; +} + + +typedef struct { + UNKNOWN u; // expected-error {{unknown type name 'UNKNOWN'}} +} AA; + +typedef struct { + AA; // expected-warning {{anonymous structs are a Microsoft extension}} +} BB; + +__declspec(deprecated("This is deprecated")) enum DE1 { one, two } e1; +struct __declspec(deprecated) DS1 { int i; float f; }; + +#define MY_TEXT "This is also deprecated" +__declspec(deprecated(MY_TEXT)) void Dfunc1( void ) {} + +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 +} diff --git a/clang/test/Sema/PR2727.c b/clang/test/Sema/PR2727.c new file mode 100644 index 0000000..332b0df --- /dev/null +++ b/clang/test/Sema/PR2727.c @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 -verify -fsyntax-only -std=c90 %s +// RUN: %clang_cc1 -verify -fsyntax-only -std=c99 %s + +int f (int x) +{ + // sizeof applied to a type should not delete the type. + return sizeof (int[x]); +} diff --git a/clang/test/Sema/PR2728.c b/clang/test/Sema/PR2728.c new file mode 100644 index 0000000..e9f1dea --- /dev/null +++ b/clang/test/Sema/PR2728.c @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 -verify -fsyntax-only -std=c90 %s +// RUN: %clang_cc1 -verify -fsyntax-only -std=c99 %s + +struct s +{ + int a; +}; + +int a[__builtin_offsetof(struct s, a) == 0]; diff --git a/clang/test/Sema/PR2919-builtin-types-compat-strips-crv.c b/clang/test/Sema/PR2919-builtin-types-compat-strips-crv.c new file mode 100644 index 0000000..9c13357 --- /dev/null +++ b/clang/test/Sema/PR2919-builtin-types-compat-strips-crv.c @@ -0,0 +1,7 @@ +// RUN: %clang_cc1 -fsyntax-only %s + +typedef struct foo T0; +typedef const struct foo T1; + +int a0[__builtin_types_compatible_p(T0, + const T1) ? 1 : -1]; diff --git a/clang/test/Sema/PR2923.c b/clang/test/Sema/PR2923.c new file mode 100644 index 0000000..f22e70d --- /dev/null +++ b/clang/test/Sema/PR2923.c @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// Test for absence of crash reported in PR 2923: +// +// http://llvm.org/bugs/show_bug.cgi?id=2923 +// +// Previously we had a crash when deallocating the FunctionDecl for 'bar' +// because FunctionDecl::getNumParams() just used the type of foo to determine +// the number of parameters it has. In the case of 'bar' there are no +// ParmVarDecls. +int foo(int x, int y) { return x + y; } +extern typeof(foo) bar; diff --git a/clang/test/Sema/PR2963-enum-constant.c b/clang/test/Sema/PR2963-enum-constant.c new file mode 100644 index 0000000..43daabf --- /dev/null +++ b/clang/test/Sema/PR2963-enum-constant.c @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only + +typedef short short_fixed; + +enum +{ + // 8.8 short_fixed + SHORT_FIXED_FRACTIONAL_BITS= 8, + SHORT_FIXED_ONE= 1<<SHORT_FIXED_FRACTIONAL_BITS +}; + +#define FLOAT_TO_SHORT_FIXED(f) ((short_fixed)((f)*SHORT_FIXED_ONE)) + +enum +{ + SOME_VALUE= FLOAT_TO_SHORT_FIXED(0.1) // expected-warning{{expression is not an integer constant expression}} +}; diff --git a/clang/test/Sema/__try.c b/clang/test/Sema/__try.c new file mode 100644 index 0000000..1641402 --- /dev/null +++ b/clang/test/Sema/__try.c @@ -0,0 +1,172 @@ +// RUN: %clang_cc1 -fborland-extensions -fsyntax-only -verify %s + +#define JOIN2(x,y) x ## y +#define JOIN(x,y) JOIN2(x,y) +#define TEST2(name) JOIN(name,__LINE__) +#define TEST TEST2(test) +typedef int DWORD; + +#pragma sysheader begin + +struct EXCEPTION_INFO{}; + +int __exception_code(); +struct EXCEPTION_INFO* __exception_info(); +void __abnormal_termination(); + +#define GetExceptionCode __exception_code +#define GetExceptionInformation __exception_info +#define AbnormalTermination __abnormal_termination + +#pragma sysheader end + +DWORD FilterExpression(int); // expected-note{{declared here}} +DWORD FilterExceptionInformation(struct EXCEPTION_INFO*); + +const char * NotFilterExpression(); + +void TEST() { + __try { + __try { + __try { + } + __finally{ + } + } + __finally{ + } + } + __finally{ + } +} + +void TEST() { + __try { + + } +} // expected-error{{expected '__except' or '__finally' block}} + +void TEST() { + __except ( FilterExpression() ) { // expected-warning{{implicit declaration of function '__except' is invalid in C99}} \ + // expected-error{{too few arguments to function call, expected 1, have 0}} + + } +} + +void TEST() { + __finally { } // expected-error{{}} +} + +void TEST() { + __try{ + int try_scope = 0; + } // TODO: expected expression is an extra error + __except( try_scope ? 1 : -1 ) // expected-error{{undeclared identifier 'try_scope'}} expected-error{{expected expression}} + {} +} + +void TEST() { + __try { + + } + // TODO: Why are there two errors? + __except( ) { // expected-error{{expected expression}} expected-error{{expected expression}} + } +} + +void TEST() { + __try { + + } + __except ( FilterExpression(GetExceptionCode()) ) { + + } + + __try { + + } + __except( FilterExpression(__exception_code()) ) { + + } + + __try { + + } + __except( FilterExceptionInformation(__exception_info()) ) { + + } + + __try { + + } + __except(FilterExceptionInformation( GetExceptionInformation() ) ) { + + } +} + +void TEST() { + __try { + + } + __except ( NotFilterExpression() ) { // expected-error{{filter expression type should be an integral value not 'const char *'}} + + } +} + +void TEST() { + int function_scope = 0; + __try { + int try_scope = 0; + } + __except ( FilterExpression(GetExceptionCode()) ) { + (void)function_scope; + (void)try_scope; // expected-error{{undeclared identifier}} + } +} + +void TEST() { + int function_scope = 0; + __try { + int try_scope = 0; + } + __finally { + (void)function_scope; + (void)try_scope; // expected-error{{undeclared identifier}} + } +} + +void TEST() { + int function_scope = 0; + __try { + + } + __except( function_scope ? 1 : -1 ) {} +} + +void TEST() { + __try { + (void)AbnormalTermination; // expected-error{{only allowed in __finally block}} + (void)__abnormal_termination; // expected-error{{only allowed in __finally block}} + } + __except( 1 ) { + (void)AbnormalTermination; // expected-error{{only allowed in __finally block}} + (void)__abnormal_termination; // expected-error{{only allowed in __finally block}} + } + + __try { + } + __finally { + AbnormalTermination(); + __abnormal_termination(); + } +} + +void TEST() { + (void)__exception_code; // expected-error{{only allowed in __except block}} + (void)__exception_info; // expected-error{{only allowed in __except filter expression}} + (void)__abnormal_termination; // expected-error{{only allowed in __finally block}} + + (void)GetExceptionCode(); // expected-error{{only allowed in __except block}} + (void)GetExceptionInformation(); // expected-error{{only allowed in __except filter expression}} + (void)AbnormalTermination(); // expected-error{{only allowed in __finally block}} +} diff --git a/clang/test/Sema/address-constant.c b/clang/test/Sema/address-constant.c new file mode 100644 index 0000000..e842a73 --- /dev/null +++ b/clang/test/Sema/address-constant.c @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +int i; +int a[] = {0}; +struct { int i; } s; + +int *array[] = {&i, a, &s.i}; + +extern void f(void); +void (*f_addr)(void) = &f; diff --git a/clang/test/Sema/address_spaces.c b/clang/test/Sema/address_spaces.c new file mode 100644 index 0000000..24799da --- /dev/null +++ b/clang/test/Sema/address_spaces.c @@ -0,0 +1,50 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify + +#define _AS1 __attribute__((address_space(1))) +#define _AS2 __attribute__((address_space(2))) +#define _AS3 __attribute__((address_space(3))) + +void bar(_AS2 int a); // expected-error {{parameter may not be qualified with an address space}} + +void foo(_AS3 float *a, + _AS1 float b) // expected-error {{parameter may not be qualified with an address space}} +{ + _AS2 *x;// expected-warning {{type specifier missing, defaults to 'int'}} + _AS1 float * _AS2 *B; + + int _AS1 _AS2 *Y; // expected-error {{multiple address spaces specified for type}} + int *_AS1 _AS2 *Z; // expected-error {{multiple address spaces specified for type}} + + _AS1 int local; // expected-error {{automatic variable qualified with an address space}} + _AS1 int array[5]; // expected-error {{automatic variable qualified with an address space}} + _AS1 int arrarr[5][5]; // expected-error {{automatic variable qualified with an address space}} + + __attribute__((address_space(-1))) int *_boundsA; // expected-error {{address space is negative}} + __attribute__((address_space(0xFFFFFF))) int *_boundsB; + __attribute__((address_space(0x1000000))) int *_boundsC; // expected-error {{address space is larger than the maximum supported}} + // chosen specifically to overflow 32 bits and come out reasonable + __attribute__((address_space(4294967500))) int *_boundsD; // expected-error {{address space is larger than the maximum supported}} + + *a = 5.0f + b; +} + +struct _st { + int x, y; +} s __attribute ((address_space(1))) = {1, 1}; + + +// rdar://6774906 +__attribute__((address_space(256))) void * * const base = 0; +void * get_0(void) { + return base[0]; // expected-error {{returning '__attribute__((address_space(256))) void *' from a function with result type 'void *' changes address space of pointer}} +} + +__attribute__((address_space(1))) char test3_array[10]; +void test3(void) { + extern void test3_helper(char *p); // expected-note {{passing argument to parameter 'p' here}} + test3_helper(test3_array); // expected-error {{changes address space of pointer}} +} + +typedef void ft(void); +_AS1 ft qf; // expected-error {{function type may not be qualified with an address space}} +typedef _AS1 ft qft; // expected-error {{function type may not be qualified with an address space}} diff --git a/clang/test/Sema/align-arm-apcs.c b/clang/test/Sema/align-arm-apcs.c new file mode 100644 index 0000000..0a5d3fe --- /dev/null +++ b/clang/test/Sema/align-arm-apcs.c @@ -0,0 +1,4 @@ +// RUN: %clang_cc1 -triple arm-unknown-unknown -target-abi apcs-gnu -fsyntax-only -verify %s + +struct s0 { double f0; int f1; }; +char chk0[__alignof__(struct s0) == 4 ? 1 : -1]; diff --git a/clang/test/Sema/align-x86-64.c b/clang/test/Sema/align-x86-64.c new file mode 100644 index 0000000..edea5d8 --- /dev/null +++ b/clang/test/Sema/align-x86-64.c @@ -0,0 +1,25 @@ +// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fsyntax-only -verify %s + +// PR5599 + +void frob(void *); + +void foo(void) { + float x[4]; + char y[__alignof__(x) == 16 ? 1 : -1]; + frob(y); +} + +// PR5637 + +typedef __attribute__((aligned(16))) struct { + unsigned long long w[3]; +} UINT192; + +UINT192 ten2mk192M[] = { + {{0xcddd6e04c0592104ULL, 0x0fcf80dc33721d53ULL, 0xa7c5ac471b478423ULL}}, + {{0xcddd6e04c0592104ULL, 0x0fcf80dc33721d53ULL, 0xa7c5ac471b478423ULL}}, + {{0xcddd6e04c0592104ULL, 0x0fcf80dc33721d53ULL, 0xa7c5ac471b478423ULL}} +}; + +short chk1[sizeof(ten2mk192M) == 80 ? 1 : -1]; diff --git a/clang/test/Sema/align-x86.c b/clang/test/Sema/align-x86.c new file mode 100644 index 0000000..c6cd754 --- /dev/null +++ b/clang/test/Sema/align-x86.c @@ -0,0 +1,48 @@ +// RUN: %clang_cc1 -triple i386-apple-darwin9 -fsyntax-only -verify %s + +// PR3433 +double g1; +short chk1[__alignof__(g1) == 8 ? 1 : -1]; +short chk2[__alignof__(double) == 8 ? 1 : -1]; + +long long g2; +short chk1[__alignof__(g2) == 8 ? 1 : -1]; +short chk2[__alignof__(long long) == 8 ? 1 : -1]; + +unsigned long long g5; +short chk1[__alignof__(g5) == 8 ? 1 : -1]; +short chk2[__alignof__(unsigned long long) == 8 ? 1 : -1]; + +_Complex double g3; +short chk1[__alignof__(g3) == 8 ? 1 : -1]; +short chk2[__alignof__(_Complex double) == 8 ? 1 : -1]; + +// PR6362 +struct __attribute__((packed)) {unsigned int a;} g4; +short chk1[__alignof__(g4) == 1 ? 1 : -1]; +short chk2[__alignof__(g4.a) == 1 ? 1 : -1]; + + +// PR5637 + +#define ALIGNED(x) __attribute__((aligned(x))) + +typedef ALIGNED(2) struct { + char a[3]; +} T; + +short chk1[sizeof(T) == 3 ? 1 : -1]; +short chk2[sizeof(T[1]) == 4 ? 1 : -1]; +short chk3[sizeof(T[2]) == 6 ? 1 : -1]; +short chk4[sizeof(T[2][1]) == 8 ? 1 : -1]; +short chk5[sizeof(T[1][2]) == 6 ? 1 : -1]; + +typedef struct ALIGNED(2) { + char a[3]; +} T2; + +short chk1[sizeof(T2) == 4 ? 1 : -1]; +short chk2[sizeof(T2[1]) == 4 ? 1 : -1]; +short chk3[sizeof(T2[2]) == 8 ? 1 : -1]; +short chk4[sizeof(T2[2][1]) == 8 ? 1 : -1]; +short chk5[sizeof(T2[1][2]) == 8 ? 1 : -1]; diff --git a/clang/test/Sema/alignas.c b/clang/test/Sema/alignas.c new file mode 100644 index 0000000..5832393 --- /dev/null +++ b/clang/test/Sema/alignas.c @@ -0,0 +1,19 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c1x %s + +_Alignas(3) int align_illegal; //expected-error {{requested alignment is not a power of 2}} +_Alignas(int) char align_big; +_Alignas(1) int align_small; // FIXME: this should be rejected +_Alignas(1) unsigned _Alignas(8) int _Alignas(1) align_multiple; + +struct align_member { + _Alignas(8) int member; +}; + +typedef _Alignas(8) char align_typedef; // FIXME: this should be rejected + +_Static_assert(__alignof(align_big) == __alignof(int), "k's alignment is wrong"); +_Static_assert(__alignof(align_small) == 1, "j's alignment is wrong"); +_Static_assert(__alignof(align_multiple) == 8, "l's alignment is wrong"); +_Static_assert(__alignof(struct align_member) == 8, "quuux's alignment is wrong"); +_Static_assert(sizeof(struct align_member) == 8, "quuux's size is wrong"); +_Static_assert(__alignof(align_typedef) == 8, "typedef's alignment is wrong"); diff --git a/clang/test/Sema/altivec-init.c b/clang/test/Sema/altivec-init.c new file mode 100644 index 0000000..973aab1 --- /dev/null +++ b/clang/test/Sema/altivec-init.c @@ -0,0 +1,47 @@ +// RUN: %clang_cc1 %s -triple=powerpc-apple-darwin8 -faltivec -verify -pedantic -fsyntax-only + +typedef int v4 __attribute((vector_size(16))); +typedef short v8 __attribute((vector_size(16))); + +v8 foo(void) { + v8 a; + v4 b; + a = (v8){4, 2}; + b = (v4)(5, 6, 7, 8, 9); // expected-warning {{excess elements in vector initializer}} + b = (v4)(5, 6, 8, 8.0f); + + vector int vi; + vi = (vector int)(1); + vi = (vector int)(1, 2); // expected-error {{number of elements must be either one or match the size of the vector}} + vi = (vector int)(1, 2, 3, 4); + vi = (vector int)(1, 2, 3, 4, 5); // expected-warning {{excess elements in vector initializer}} + vi = (vector int){1}; + vi = (vector int){1, 2}; + vi = (vector int){1, 2, 3, 4, 5}; // expected-warning {{excess elements in vector initializer}} + vector float vf; + vf = (vector float)(1.0); + + return (v8){0, 1, 2, 3, 1, 2, 3, 4}; + + // FIXME: test that (type)(fn)(args) still works with -faltivec + // FIXME: test that c++ overloaded commas still work -faltivec +} + +void __attribute__((__overloadable__)) f(v4 a) +{ +} + +void __attribute__((__overloadable__)) f(int a) +{ +} + +void test() +{ + v4 vGCC; + vector int vAltiVec; + + f(vAltiVec); + vGCC = vAltiVec; + int res = vGCC > vAltiVec; + vAltiVec = 0 ? vGCC : vGCC; +} diff --git a/clang/test/Sema/annotate.c b/clang/test/Sema/annotate.c new file mode 100644 index 0000000..5b27277 --- /dev/null +++ b/clang/test/Sema/annotate.c @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify + +void __attribute__((annotate("foo"))) foo(float *a) { + __attribute__((annotate("bar"))) int x; + __attribute__((annotate(1))) int y; // expected-error {{argument to annotate attribute was not a string literal}} + __attribute__((annotate("bar", 1))) int z; // expected-error {{attribute takes one argument}} + int u = __builtin_annotation(z, (char*) 0); // expected-error {{__builtin_annotation requires a non wide string constant}} + int v = __builtin_annotation(z, (char*) L"bar"); // expected-error {{__builtin_annotation requires a non wide string constant}} + int w = __builtin_annotation(z, "foo"); +} diff --git a/clang/test/Sema/anonymous-struct-union-c11.c b/clang/test/Sema/anonymous-struct-union-c11.c new file mode 100644 index 0000000..229ee52 --- /dev/null +++ b/clang/test/Sema/anonymous-struct-union-c11.c @@ -0,0 +1,19 @@ +// Check for warnings in non-C11 mode: +// RUN: %clang_cc1 -fsyntax-only -verify -Wc11-extensions %s + +// Expect no warnings in C11 mode: +// RUN: %clang_cc1 -fsyntax-only -pedantic -Werror -std=c11 %s + +struct s { + int a; + struct { // expected-warning{{anonymous structs are a C11 extension}} + int b; + }; +}; + +struct t { + int a; + union { // expected-warning{{anonymous unions are a C11 extension}} + int b; + }; +}; diff --git a/clang/test/Sema/anonymous-struct-union.c b/clang/test/Sema/anonymous-struct-union.c new file mode 100644 index 0000000..e082290 --- /dev/null +++ b/clang/test/Sema/anonymous-struct-union.c @@ -0,0 +1,110 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +struct X { + union { + float f3; + double d2; + } named; + + union { + int i; + float f; + + union { + float f2; + double d; + }; + }; + + struct { + int a; + float b; + }; +}; + +void test_unqual_references(struct X x, const struct X xc) { + x.i = 0; + x.f = 0.0; + x.f2 = x.f; + x.d = x.f; + x.f3 = 0; // expected-error{{no member named 'f3'}} + x.a = 0; + + xc.d = 0.0; // expected-error{{read-only variable is not assignable}} + xc.f = 0; // expected-error{{read-only variable is not assignable}} + xc.a = 0; // expected-error{{read-only variable is not assignable}} +} + + +struct Redecl { + int x; // expected-note{{previous declaration is here}} + struct y { }; + + union { + int x; // expected-error{{member of anonymous union redeclares 'x'}} + float y; + double z; // expected-note{{previous declaration is here}} + double zz; // expected-note{{previous declaration is here}} + }; + + int z; // expected-error{{duplicate member 'z'}} + void zz(); // expected-error{{duplicate member 'zz'}} +}; + +union { // expected-warning{{declaration does not declare anything}} + int int_val; + float float_val; +}; + +static union { // expected-warning{{declaration does not declare anything}} + int int_val2; + float float_val2; +}; + +void f() { + int_val2 = 0; // expected-error{{use of undeclared identifier}} + float_val2 = 0.0; // expected-error{{use of undeclared identifier}} +} + +void g() { + union { // expected-warning{{declaration does not declare anything}} + int i; + float f2; + }; + i = 0; // expected-error{{use of undeclared identifier}} + f2 = 0.0; // expected-error{{use of undeclared identifier}} +} + +// <rdar://problem/6483159> +struct s0 { union { int f0; }; }; + +// <rdar://problem/6481130> +typedef struct { }; // expected-warning{{declaration does not declare anything}} + +// PR3675 +struct s1 { + int f0; // expected-note{{previous declaration is here}} + union { + int f0; // expected-error{{member of anonymous union redeclares 'f0'}} + }; +}; + +// PR3680 +struct {}; // expected-warning{{declaration does not declare anything}} + +struct s2 { + union { + int a; + } // expected-warning{{expected ';' at end of declaration list}} +}; // expected-error{{expected member name or ';' after declaration specifiers}} + +// Make sure we don't a.k.a. anonymous structs. +typedef struct { + int x; +} a_struct; +int tmp = (a_struct) { .x = 0 }; // expected-error {{initializing 'int' with an expression of incompatible type 'a_struct'}} + +// This example comes out of the C11 standard; make sure we don't accidentally reject it. +struct s { + struct { int i; }; + int a[]; +}; diff --git a/clang/test/Sema/arg-duplicate.c b/clang/test/Sema/arg-duplicate.c new file mode 100644 index 0000000..feeb458 --- /dev/null +++ b/clang/test/Sema/arg-duplicate.c @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +int f3(y, x, + x) // expected-error {{redefinition of parameter}} + int y, + x, // expected-note {{previous declaration is here}} + x; // expected-error {{redefinition of parameter}} +{ + return x + y; +} + +void f4(void) { + f3 (1, 1, 2, 3, 4); // expected-warning{{too many arguments}} +} + diff --git a/clang/test/Sema/arg-scope-c99.c b/clang/test/Sema/arg-scope-c99.c new file mode 100644 index 0000000..912776a --- /dev/null +++ b/clang/test/Sema/arg-scope-c99.c @@ -0,0 +1,2 @@ +// RUN: %clang_cc1 -fsyntax-only -std=c99 -verify %s +void bb(int sz, int ar[sz][sz]) { } diff --git a/clang/test/Sema/arg-scope.c b/clang/test/Sema/arg-scope.c new file mode 100644 index 0000000..ed92619 --- /dev/null +++ b/clang/test/Sema/arg-scope.c @@ -0,0 +1,5 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +void aa(int b, int x[sizeof b]) {} + +void foo(int i, int A[i]) {} + diff --git a/clang/test/Sema/arm-layout.c b/clang/test/Sema/arm-layout.c new file mode 100644 index 0000000..d017fdb --- /dev/null +++ b/clang/test/Sema/arm-layout.c @@ -0,0 +1,53 @@ +// RUN: %clang_cc1 -triple armv7-unknown-unknown -target-abi apcs-gnu %s -verify +// RUN: %clang_cc1 -triple armv7-unknown-unknown -target-abi aapcs %s -verify + +#define check(name, cond) int _##name##_check[(cond) ? 1 : -1] + +struct s0 { char field0; double field1; }; +#ifdef __ARM_EABI__ +check(s0_size, sizeof(struct s0) == 16); +#else +check(s0_size, sizeof(struct s0) == 12); +#endif + +struct s1 { char field0; long double field1; }; +#ifdef __ARM_EABI__ +check(s1_size, sizeof(struct s1) == 16); +#else +check(s1_size, sizeof(struct s1) == 12); +#endif + +struct s2 { + short field0; + int field1 : 24; + char field2; +}; +#ifdef __ARM_EABI__ +check(s2_size, sizeof(struct s2) == 8); +check(s2_offset_0, __builtin_offsetof(struct s2, field0) == 0); +check(s2_offset_1, __builtin_offsetof(struct s2, field2) == 7); +#else +check(s2_size, sizeof(struct s2) == 6); +check(s2_offset_0, __builtin_offsetof(struct s2, field0) == 0); +check(s2_offset_1, __builtin_offsetof(struct s2, field2) == 5); +#endif + +struct s3 { + short field0; + int field1 : 24 __attribute__((aligned(4))); + char field2; +}; +check(s3_size, sizeof(struct s3) == 8); +check(s3_offset_0, __builtin_offsetof(struct s3, field0) == 0); +check(s3_offset_1, __builtin_offsetof(struct s3, field2) == 7); + +struct s4 { + int field0 : 4; +}; +#ifdef __ARM_EABI__ +check(s4_size, sizeof(struct s4) == 4); +check(s4_align, __alignof(struct s4) == 4); +#else +check(s4_size, sizeof(struct s4) == 1); +check(s4_align, __alignof(struct s4) == 1); +#endif diff --git a/clang/test/Sema/arm-neon-types.c b/clang/test/Sema/arm-neon-types.c new file mode 100644 index 0000000..1a170db --- /dev/null +++ b/clang/test/Sema/arm-neon-types.c @@ -0,0 +1,35 @@ +// RUN: %clang_cc1 -triple thumbv7-apple-darwin10 -target-cpu cortex-a8 -fsyntax-only -Wvector-conversion -ffreestanding -verify %s + +#include <arm_neon.h> + +// Radar 8228022: Should not report incompatible vector types. +int32x2_t test(int32x2_t x) { + return vshr_n_s32(x, 31); +} + +// ...but should warn when the types really do not match. +float32x2_t test2(uint32x2_t x) { + return vcvt_n_f32_s32(x, 9); // expected-warning {{incompatible vector types}} +} + +// Check immediate range for vcvt_n intrinsics is 1 to 32. Radar 9558930. +float32x2_t test3(uint32x2_t x) { + // FIXME: The "incompatible result type" error is due to pr10112 and should be + // removed when that is fixed. + return vcvt_n_f32_u32(x, 0); // expected-error {{argument should be a value from 1 to 32}} expected-error {{incompatible result type}} +} + +typedef signed int vSInt32 __attribute__((__vector_size__(16))); +int32x4_t test4(int32x4_t a, vSInt32 b) { + a += b; + b += a; + return b += a; +} + +// Warn for incompatible pointer types used with vld/vst intrinsics. +int16x8_t test5(int *p) { + return vld1q_s16(p); // expected-warning {{incompatible pointer types}} +} +void test6(float *p, int32x2_t v) { + return vst1_s32(p, v); // expected-warning {{incompatible pointer types}} +} diff --git a/clang/test/Sema/array-bounds-ptr-arith.c b/clang/test/Sema/array-bounds-ptr-arith.c new file mode 100644 index 0000000..022335b --- /dev/null +++ b/clang/test/Sema/array-bounds-ptr-arith.c @@ -0,0 +1,21 @@ +// RUN: %clang_cc1 -verify -Warray-bounds-pointer-arithmetic %s + +// Test case from PR10615 +struct ext2_super_block{ + unsigned char s_uuid[8]; // expected-note {{declared here}} +}; +void* ext2_statfs (struct ext2_super_block *es,int a) +{ + return (void *)es->s_uuid + sizeof(int); // no-warning +} +void* broken (struct ext2_super_block *es,int a) +{ + return (void *)es->s_uuid + 80; // expected-warning {{refers past the end of the array}} +} + +// Test case reduced from PR11594 +struct S { int n; }; +void pr11594(struct S *s) { + int a[10]; + int *p = a - s->n; +} diff --git a/clang/test/Sema/array-constraint.c b/clang/test/Sema/array-constraint.c new file mode 100644 index 0000000..bee33c0 --- /dev/null +++ b/clang/test/Sema/array-constraint.c @@ -0,0 +1,52 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -pedantic %s + +struct s; // expected-note 2 {{forward declaration of 'struct s'}} +struct s* t (struct s z[]) { // expected-error {{array has incomplete element type}} + return z; +} + +void ff() { + struct s v, *p; // expected-error {{variable has incomplete type 'struct s'}} + + p = &v; +} + +void *k (void l[2]) { // expected-error {{array has incomplete element type}} + return l; +} + +struct vari { + int a; + int b[]; +}; + +struct vari *func(struct vari a[]) { // expected-warning {{'struct vari' may not be used as an array element due to flexible array member}} + return a; +} + +int foo[](void); // expected-error {{'foo' declared as array of functions}} +int foo2[1](void); // expected-error {{'foo2' declared as array of functions}} + +typedef int (*pfunc)(void); + +pfunc xx(int f[](void)) { // expected-error {{'f' declared as array of functions}} + return f; +} + +void check_size() { + float f; + int size_not_int[f]; // expected-error {{size of array has non-integer type 'float'}} + int negative_size[1-2]; // expected-error{{array with a negative size}} + int zero_size[0]; // expected-warning{{zero size arrays are an extension}} +} + +static int I; +typedef int TA[I]; // expected-error {{variable length array declaration not allowed at file scope}} + +void strFunc(char *); // expected-note{{passing argument to parameter here}} +const char staticAry[] = "test"; +void checkStaticAry() { + strFunc(staticAry); // expected-warning{{passing 'const char [5]' to parameter of type 'char *' discards qualifiers}} +} + + diff --git a/clang/test/Sema/array-declared-as-incorrect-type.c b/clang/test/Sema/array-declared-as-incorrect-type.c new file mode 100644 index 0000000..b93fa9a --- /dev/null +++ b/clang/test/Sema/array-declared-as-incorrect-type.c @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -pedantic %s + +extern int a1[]; +int a1[1]; + +extern int a2[]; // expected-note {{previous definition is here}} +float a2[1]; // expected-error {{redefinition of 'a2'}} + +extern int a3[][2]; +int a3[1][2]; + +extern int a4[][2]; // expected-note {{previous definition is here}} +int a4[2]; // expected-error {{redefinition of 'a4'}} + +extern int a5[1][2][3]; // expected-note {{previous definition is here}} +int a5[3][2][1]; // expected-error {{redefinition of 'a5'}} diff --git a/clang/test/Sema/array-init.c b/clang/test/Sema/array-init.c new file mode 100644 index 0000000..26c0b24 --- /dev/null +++ b/clang/test/Sema/array-init.c @@ -0,0 +1,289 @@ +// RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s + +extern int foof() = 1; // expected-error{{illegal initializer (only variables can be initialized)}} + +static int x, y, z; + +static int ary[] = { x, y, z }; // expected-error{{initializer element is not a compile-time constant}} +int ary2[] = { x, y, z }; // expected-error{{initializer element is not a compile-time constant}} + +extern int fileScopeExtern[3] = { 1, 3, 5 }; // expected-warning{{'extern' variable has an initializer}} + +static long ary3[] = { 1, "abc", 3, 4 }; // expected-warning{{incompatible pointer to integer conversion initializing 'long' with an expression of type 'char [4]'}} + +void func() { + int x = 1; + + typedef int TInt = 1; // expected-error{{illegal initializer (only variables can be initialized)}} + + int xComputeSize[] = { 1, 3, 5 }; + + int x3[x] = { 1, 2 }; // expected-error{{variable-sized object may not be initialized}} + + int x4 = { 1, 2 }; // expected-warning{{excess elements in scalar initializer}} + + int y[4][3] = { + { 1, 3, 5 }, + { 2, 4, 6 }, + { 3, 5, 7 }, + }; + + int y2[4][3] = { + 1, 3, 5, 2, 4, 6, 3, 5, 7 + }; + + int y3[4][3] = { + { 1, 3, 5 }, + { 2, 4, 6 }, + { 3, 5, 7 }, + { 4, 6, 8 }, + { 5 }, // expected-warning{{excess elements in array initializer}} + }; + + struct threeElements { + int a,b,c; + } z = { 1 }; + + struct threeElements *p = 7; // expected-warning{{incompatible integer to pointer conversion initializing 'struct threeElements *' with an expression of type 'int'}} + + extern int blockScopeExtern[3] = { 1, 3, 5 }; // expected-error{{'extern' variable cannot have an initializer}} + + static long x2[3] = { 1.0, + "abc", // expected-warning{{incompatible pointer to integer conversion initializing 'long' with an expression of type 'char [4]'}} + 5.8 }; // expected-warning {{implicit conversion turns literal floating-point number into integer}} +} + +void test() { + int y1[3] = { + { 1, 2, 3 } // expected-warning{{excess elements in scalar initializer}} + }; + int y3[4][3] = { + { 1, 3, 5 }, + { 2, 4, 6 }, + { 3, 5, 7 }, + { 4, 6, 8 }, + { }, // expected-warning{{use of GNU empty initializer extension}} expected-warning{{excess elements in array initializer}} + }; + int y4[4][3] = { + { 1, 3, 5, 2 }, // expected-warning{{excess elements in array initializer}} + { 4, 6 }, + { 3, 5, 7 }, + { 4, 6, 8 }, + }; +} + +void allLegalAndSynonymous() { + short q[4][3][2] = { + { 1 }, + { 2, 3 }, + { 4, 5, 6 } + }; + short q2[4][3][2] = { + { 1, 0, 0, 0, 0, 0 }, + { 2, 3, 0, 0, 0, 0 }, + { 4, 5, 6 } + }; + short q3[4][3][2] = { + { + { 1 }, + }, + { + { 2, 3 }, + }, + { + { 4, 5 }, + { 6 }, + }, + }; +} + +void legal() { + short q[][3][2] = { + { 1 }, + { 2, 3 }, + { 4, 5, 6 } + }; + int q_sizecheck[(sizeof(q) / sizeof(short [3][2])) == 3? 1 : -1]; +} + +unsigned char asso_values[] = { 34 }; +int legal2() { + return asso_values[0]; +} + +void illegal() { + short q2[4][][2] = { // expected-error{{array has incomplete element type 'short [][2]'}} + { 1, 0, 0, 0, 0, 0 }, + { 2, 3, 0, 0, 0, 0 }, + { 4, 5, 6 } + }; + short q3[4][3][] = { // expected-error{{array has incomplete element type 'short []'}} + { + { 1 }, + }, + { + { 2, 3 }, + }, + { + { 4, 5 }, + { 6 }, + }, + }; + int a[][] = { 1, 2 }; // expected-error{{array has incomplete element type 'int []'}} +} + +typedef int AryT[]; + +void testTypedef() +{ + AryT a = { 1, 2 }, b = { 3, 4, 5 }; + int a_sizecheck[(sizeof(a) / sizeof(int)) == 2? 1 : -1]; + int b_sizecheck[(sizeof(b) / sizeof(int)) == 3? 1 : -1]; +} + +static char const xx[] = "test"; +int xx_sizecheck[(sizeof(xx) / sizeof(char)) == 5? 1 : -1]; +static char const yy[5] = "test"; +static char const zz[3] = "test"; // expected-warning{{initializer-string for char array is too long}} + +void charArrays() { + static char const test[] = "test"; + int test_sizecheck[(sizeof(test) / sizeof(char)) == 5? 1 : -1]; + static char const test2[] = { "weird stuff" }; + static char const test3[] = { "test", "excess stuff" }; // expected-warning{{excess elements in char array initializer}} + + char* cp[] = { "Hello" }; + + char c[] = { "Hello" }; + int l[sizeof(c) == 6 ? 1 : -1]; + + int i[] = { "Hello "}; // expected-warning{{incompatible pointer to integer conversion initializing 'int' with an expression of type 'char [7]'}} + char c2[] = { "Hello", "Good bye" }; //expected-warning{{excess elements in char array initializer}} + + int i2[1] = { "Hello" }; //expected-warning{{incompatible pointer to integer conversion initializing 'int' with an expression of type 'char [6]'}} + char c3[5] = { "Hello" }; + char c4[4] = { "Hello" }; //expected-warning{{initializer-string for char array is too long}} + + int i3[] = {}; //expected-warning{{zero size arrays are an extension}} expected-warning{{use of GNU empty initializer extension}} +} + +void variableArrayInit() { + int a = 4; + char strlit[a] = "foo"; //expected-error{{variable-sized object may not be initialized}} + int b[a] = { 1, 2, 4 }; //expected-error{{variable-sized object may not be initialized}} +} + +// Pure array tests +float r1[10] = {{7}}; //expected-warning{{braces around scalar initializer}} +float r2[] = {{8}}; //expected-warning{{braces around scalar initializer}} +char r3[][5] = {1,2,3,4,5,6}; +int r3_sizecheck[(sizeof(r3) / sizeof(char[5])) == 2? 1 : -1]; +char r3_2[sizeof r3 == 10 ? 1 : -1]; +float r4[1][2] = {1,{2},3,4}; //expected-warning{{braces around scalar initializer}} expected-warning{{excess elements in array initializer}} +char r5[][5] = {"aa", "bbb", "ccccc"}; +char r6[sizeof r5 == 15 ? 1 : -1]; +const char r7[] = "zxcv"; +char r8[5] = "5char"; +char r9[5] = "6chars"; //expected-warning{{initializer-string for char array is too long}} + +int r11[0] = {}; //expected-warning{{zero size arrays are an extension}} expected-warning{{use of GNU empty initializer extension}} + +// Some struct tests +void autoStructTest() { +struct s1 {char a; char b;} t1; +struct s2 {struct s1 c;} t2 = { t1 }; +// The following is a less than great diagnostic (though it's on par with EDG). +struct s1 t3[] = {t1, t1, "abc", 0}; //expected-warning{{incompatible pointer to integer conversion initializing 'char' with an expression of type 'char [4]'}} +int t4[sizeof t3 == 6 ? 1 : -1]; +} +struct foo { int z; } w; +int bar (void) { + struct foo z = { w }; //expected-error{{initializing 'int' with an expression of incompatible type 'struct foo'}} + return z.z; +} +struct s3 {void (*a)(void);} t5 = {autoStructTest}; +struct {int a; int b[];} t6 = {1, {1, 2, 3}}; // expected-warning{{flexible array initialization is a GNU extension}} \ +// expected-note{{initialized flexible array member 'b' is here}} +union {char a; int b;} t7[] = {1, 2, 3}; +int t8[sizeof t7 == (3*sizeof(int)) ? 1 : -1]; + +struct bittest{int : 31, a, :21, :12, b;}; +struct bittest bittestvar = {1, 2, 3, 4}; //expected-warning{{excess elements in struct initializer}} + +// Not completely sure what should happen here... +int u1 = {}; //expected-warning{{use of GNU empty initializer extension}} expected-error{{scalar initializer cannot be empty}} +int u2 = {{3}}; //expected-warning{{too many braces around scalar initializer}} + +// PR2362 +void varArray() { + int c[][x] = { 0 }; //expected-error{{variable-sized object may not be initialized}} +} + +// PR2151 +void emptyInit() {struct {} x[] = {6};} //expected-warning{{empty struct is a GNU extension}} \ +// expected-error{{initializer for aggregate with no elements}} + +void noNamedInit() { + struct {int:5;} x[] = {6}; //expected-error{{initializer for aggregate with no elements}} +} +struct {int a; int:5;} noNamedImplicit[] = {1,2,3}; +int noNamedImplicitCheck[sizeof(noNamedImplicit) == 3 * sizeof(*noNamedImplicit) ? 1 : -1]; + + +// ptrs are constant +struct soft_segment_descriptor { + long ssd_base; +}; +static int dblfault_tss; + +union uniao { int ola; } xpto[1]; + +struct soft_segment_descriptor gdt_segs[] = { + {(long) &dblfault_tss}, + { (long)xpto}, +}; + +static void sppp_ipv6cp_up(); +const struct {} ipcp = { sppp_ipv6cp_up }; //expected-warning{{empty struct is a GNU extension}} \ +// expected-warning{{excess elements in struct initializer}} + +struct _Matrix { union { float m[4][4]; }; }; //expected-warning{{anonymous unions are a C11 extension}} +typedef struct _Matrix Matrix; +void test_matrix() { + const Matrix mat1 = { + { { 1.0f, 2.0f, 3.0f, 4.0f, + 5.0f, 6.0f, 7.0f, 8.0f, + 9.0f, 10.0f, 11.0f, 12.0f, + 13.0f, 14.0f, 15.0f, 16.0f } } + }; + + const Matrix mat2 = { + 1.0f, 2.0f, 3.0f, 4.0f, + 5.0f, 6.0f, 7.0f, 8.0f, + 9.0f, 10.0f, 11.0f, 12.0f, + 13.0f, 14.0f, 15.0f, 16.0f + }; +} + +char badchararray[1] = { badchararray[0], "asdf" }; // expected-warning {{excess elements in array initializer}} expected-error {{initializer element is not a compile-time constant}} + +// Test the GNU extension for initializing an array from an array +// compound literal. PR9261. +typedef int int5[5]; +int a1[5] = (int[]){1, 2, 3, 4, 5}; // expected-warning{{initialization of an array of type 'int [5]' from a compound literal of type 'int [5]' is a GNU extension}} +int a2[5] = (int[5]){1, 2, 3, 4, 5}; // expected-warning{{initialization of an array of type 'int [5]' from a compound literal of type 'int [5]' is a GNU extension}} +int a3[] = ((int[]){1, 2, 3, 4, 5}); // expected-warning{{initialization of an array of type 'int []' from a compound literal of type 'int [5]' is a GNU extension}} +int a4[] = (int[5]){1, 2, 3, 4, 5}; // expected-warning{{initialization of an array of type 'int []' from a compound literal of type 'int [5]' is a GNU extension}} +int a5[] = (int5){1, 2, 3, 4, 5}; // expected-warning{{initialization of an array of type 'int []' from a compound literal of type 'int5' (aka 'int [5]') is a GNU extension}} + +int a6[5] = (int[]){1, 2, 3}; // expected-error{{cannot initialize array of type 'int [5]' with array of type 'int [3]'}} + +int nonconst_value(); +int a7[5] = (int[5]){ 1, 2, 3, 4, nonconst_value() }; // expected-error{{initializer element is not a compile-time constant}} + +// <rdar://problem/10636946> +__attribute__((weak)) const unsigned int test10_bound = 10; +char test10_global[test10_bound]; // expected-error {{variable length array declaration not allowed at file scope}} +void test10() { + char test10_local[test10_bound] = "help"; // expected-error {{variable-sized object may not be initialized}} +} diff --git a/clang/test/Sema/array-size-64.c b/clang/test/Sema/array-size-64.c new file mode 100644 index 0000000..f22e8e7 --- /dev/null +++ b/clang/test/Sema/array-size-64.c @@ -0,0 +1,7 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin -verify %s + +void f() { + int a[2147483647U][2147483647U]; // expected-error{{array is too large}} + int b[1073741825U - 1U][2147483647U]; + int c[18446744073709551615U/sizeof(int)/2]; +} diff --git a/clang/test/Sema/array-size.c b/clang/test/Sema/array-size.c new file mode 100644 index 0000000..7580e3e --- /dev/null +++ b/clang/test/Sema/array-size.c @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -triple i686-apple-darwin -verify %s + +void f() { + int x0[1073741824]; // expected-error{{array is too large}} + int x1[1073741824 + 1]; // expected-error{{array is too large}} + int x2[(unsigned)1073741824]; // expected-error{{array is too large}} + int x3[(unsigned)1073741824 + 1]; // expected-error{{array is too large}} + int x4[1073741824 - 1]; +} + diff --git a/clang/test/Sema/asm.c b/clang/test/Sema/asm.c new file mode 100644 index 0000000..44d83e9 --- /dev/null +++ b/clang/test/Sema/asm.c @@ -0,0 +1,125 @@ +// RUN: %clang_cc1 %s -triple i386-pc-linux-gnu -verify -fsyntax-only + +void f() { + int i; + + asm ("foo\n" : : "a" (i + 2)); + asm ("foo\n" : : "a" (f())); // expected-error {{invalid type 'void' in asm input}} + + asm ("foo\n" : "=a" (f())); // expected-error {{invalid lvalue in asm output}} + asm ("foo\n" : "=a" (i + 2)); // expected-error {{invalid lvalue in asm output}} + + asm ("foo\n" : [symbolic_name] "=a" (i) : "[symbolic_name]" (i)); + asm ("foo\n" : "=a" (i) : "[" (i)); // expected-error {{invalid input constraint '[' in asm}} + asm ("foo\n" : "=a" (i) : "[foo" (i)); // expected-error {{invalid input constraint '[foo' in asm}} + asm ("foo\n" : "=a" (i) : "[symbolic_name]" (i)); // expected-error {{invalid input constraint '[symbolic_name]' in asm}} +} + +void clobbers() { + asm ("nop" : : : "ax", "#ax", "%ax"); + asm ("nop" : : : "eax", "rax", "ah", "al"); + asm ("nop" : : : "0", "%0", "#0"); + asm ("nop" : : : "foo"); // expected-error {{unknown register name 'foo' in asm}} + asm ("nop" : : : "52"); + asm ("nop" : : : "104"); // expected-error {{unknown register name '104' in asm}} + asm ("nop" : : : "-1"); // expected-error {{unknown register name '-1' in asm}} + asm ("nop" : : : "+1"); // expected-error {{unknown register name '+1' in asm}} +} + +// rdar://6094010 +void test3() { + int x; + asm(L"foo" : "=r"(x)); // expected-error {{wide string}} + asm("foo" : L"=r"(x)); // expected-error {{wide string}} +} + +// <rdar://problem/6156893> +void test4(const volatile void *addr) +{ + asm ("nop" : : "r"(*addr)); // expected-error {{invalid type 'const volatile void' in asm input for constraint 'r'}} + asm ("nop" : : "m"(*addr)); + + asm ("nop" : : "r"(test4(addr))); // expected-error {{invalid type 'void' in asm input for constraint 'r'}} + asm ("nop" : : "m"(test4(addr))); // expected-error {{invalid lvalue in asm input for constraint 'm'}} + + asm ("nop" : : "m"(f())); // expected-error {{invalid lvalue in asm input for constraint 'm'}} +} + +// <rdar://problem/6512595> +void test5() { + asm("nop" : : "X" (8)); +} + +// PR3385 +void test6(long i) { + asm("nop" : : "er"(i)); +} + +void asm_string_tests(int i) { + asm("%!"); // simple asm string, %! is not an error. + asm("%!" : ); // expected-error {{invalid % escape in inline assembly string}} + asm("xyz %" : ); // expected-error {{invalid % escape in inline assembly string}} + + asm ("%[somename]" :: [somename] "i"(4)); // ok + asm ("%[somename]" :: "i"(4)); // expected-error {{unknown symbolic operand name in inline assembly string}} + asm ("%[somename" :: "i"(4)); // expected-error {{unterminated symbolic operand name in inline assembly string}} + asm ("%[]" :: "i"(4)); // expected-error {{empty symbolic operand name in inline assembly string}} + + // PR3258 + asm("%9" :: "i"(4)); // expected-error {{invalid operand number in inline asm string}} + asm("%1" : "+r"(i)); // ok, referring to input. +} + +// PR4077 +int test7(unsigned long long b) { + int a; + asm volatile("foo %0 %1" : "=a" (a) :"0" (b)); // expected-error {{input with type 'unsigned long long' matching output with type 'int'}} + return a; +} + +// <rdar://problem/7574870> +asm volatile (""); // expected-warning {{meaningless 'volatile' on asm outside function}} + +// PR3904 +void test8(int i) { + // A number in an input constraint can't point to a read-write constraint. + asm("" : "+r" (i), "=r"(i) : "0" (i)); // expected-error{{invalid input constraint '0' in asm}} +} + +// PR3905 +void test9(int i) { + asm("" : [foo] "=r" (i), "=r"(i) : "1[foo]"(i)); // expected-error{{invalid input constraint '1[foo]' in asm}} + asm("" : [foo] "=r" (i), "=r"(i) : "[foo]1"(i)); // expected-error{{invalid input constraint '[foo]1' in asm}} +} + +register int g asm("dx"); // expected-error{{global register variables are not supported}} + +void test10(void){ + static int g asm ("g_asm") = 0; + extern int gg asm ("gg_asm"); + __private_extern__ int ggg asm ("ggg_asm"); + + int a asm ("a_asm"); // expected-warning{{ignored asm label 'a_asm' on automatic variable}} + auto int aa asm ("aa_asm"); // expected-warning{{ignored asm label 'aa_asm' on automatic variable}} + + register int r asm ("cx"); + register int rr asm ("rr_asm"); // expected-error{{unknown register name 'rr_asm' in asm}} +} + +// This is just an assert because of the boolean conversion. +// Feel free to change the assembly to something sensible if it causes a problem. +// rdar://problem/9414925 +void test11(void) { + _Bool b; + asm volatile ("movb %%gs:%P2,%b0" : "=q"(b) : "0"(0), "i"(5L)); +} + +void test12(void) { + register int cc __asm ("cc"); // expected-error{{unknown register name 'cc' in asm}} +} + +// PR10223 +void test13(void) { + void *esp; + __asm__ volatile ("mov %%esp, %o" : "=r"(esp) : : ); // expected-error {{invalid % escape in inline assembly string}} +} diff --git a/clang/test/Sema/assign-null.c b/clang/test/Sema/assign-null.c new file mode 100644 index 0000000..7f172b1 --- /dev/null +++ b/clang/test/Sema/assign-null.c @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +#include <stddef.h> + +typedef void (*hookfunc)(void *arg); +hookfunc hook; + +void clear_hook() { + hook = NULL; +} diff --git a/clang/test/Sema/assign.c b/clang/test/Sema/assign.c new file mode 100644 index 0000000..2d57029 --- /dev/null +++ b/clang/test/Sema/assign.c @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +void *test1(void) { return 0; } + +void test2 (const struct {int a;} *x) { + x->a = 10; // expected-error {{read-only variable is not assignable}} +} + +typedef int arr[10]; +void test3() { + const arr b; + const int b2[10]; + b[4] = 1; // expected-error {{read-only variable is not assignable}} + b2[4] = 1; // expected-error {{read-only variable is not assignable}} +} diff --git a/clang/test/Sema/ast-print.c b/clang/test/Sema/ast-print.c new file mode 100644 index 0000000..ff66d35 --- /dev/null +++ b/clang/test/Sema/ast-print.c @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 %s -ast-print + +typedef void func_typedef(); +func_typedef xxx; + +typedef void func_t(int x); +func_t a; + diff --git a/clang/test/Sema/atomic-ops.c b/clang/test/Sema/atomic-ops.c new file mode 100644 index 0000000..f769271 --- /dev/null +++ b/clang/test/Sema/atomic-ops.c @@ -0,0 +1,165 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only -triple=i686-linux-gnu + +// Basic parsing/Sema tests for __c11_atomic_* + +typedef enum memory_order { + memory_order_relaxed, memory_order_consume, memory_order_acquire, + memory_order_release, memory_order_acq_rel, memory_order_seq_cst +} memory_order; + +struct S { char c[3]; }; + +_Static_assert(__GCC_ATOMIC_BOOL_LOCK_FREE == 2, ""); +_Static_assert(__GCC_ATOMIC_CHAR_LOCK_FREE == 2, ""); +_Static_assert(__GCC_ATOMIC_CHAR16_T_LOCK_FREE == 2, ""); +_Static_assert(__GCC_ATOMIC_CHAR32_T_LOCK_FREE == 2, ""); +_Static_assert(__GCC_ATOMIC_WCHAR_T_LOCK_FREE == 2, ""); +_Static_assert(__GCC_ATOMIC_SHORT_LOCK_FREE == 2, ""); +_Static_assert(__GCC_ATOMIC_INT_LOCK_FREE == 2, ""); +_Static_assert(__GCC_ATOMIC_LONG_LOCK_FREE == 2, ""); +_Static_assert(__GCC_ATOMIC_LLONG_LOCK_FREE == 1, ""); +_Static_assert(__GCC_ATOMIC_POINTER_LOCK_FREE == 2, ""); + +_Static_assert(__c11_atomic_is_lock_free(1), ""); +_Static_assert(__c11_atomic_is_lock_free(2), ""); +_Static_assert(__c11_atomic_is_lock_free(3), ""); // expected-error {{not an integral constant expression}} +_Static_assert(__c11_atomic_is_lock_free(4), ""); +_Static_assert(__c11_atomic_is_lock_free(8), ""); +_Static_assert(__c11_atomic_is_lock_free(16), ""); // expected-error {{not an integral constant expression}} +_Static_assert(__c11_atomic_is_lock_free(17), ""); // expected-error {{not an integral constant expression}} + +_Static_assert(__atomic_is_lock_free(1, 0), ""); +_Static_assert(__atomic_is_lock_free(2, 0), ""); +_Static_assert(__atomic_is_lock_free(3, 0), ""); // expected-error {{not an integral constant expression}} +_Static_assert(__atomic_is_lock_free(4, 0), ""); +_Static_assert(__atomic_is_lock_free(8, 0), ""); +_Static_assert(__atomic_is_lock_free(16, 0), ""); // expected-error {{not an integral constant expression}} +_Static_assert(__atomic_is_lock_free(17, 0), ""); // expected-error {{not an integral constant expression}} + +char i8; +short i16; +int i32; +int __attribute__((vector_size(8))) i64; +struct Incomplete *incomplete; + +_Static_assert(__atomic_is_lock_free(1, &i8), ""); +_Static_assert(__atomic_is_lock_free(1, &i64), ""); +_Static_assert(__atomic_is_lock_free(2, &i8), ""); // expected-error {{not an integral constant expression}} +_Static_assert(__atomic_is_lock_free(2, &i16), ""); +_Static_assert(__atomic_is_lock_free(2, &i64), ""); +_Static_assert(__atomic_is_lock_free(4, &i16), ""); // expected-error {{not an integral constant expression}} +_Static_assert(__atomic_is_lock_free(4, &i32), ""); +_Static_assert(__atomic_is_lock_free(4, &i64), ""); +_Static_assert(__atomic_is_lock_free(8, &i32), ""); // expected-error {{not an integral constant expression}} +_Static_assert(__atomic_is_lock_free(8, &i64), ""); + +_Static_assert(__atomic_always_lock_free(1, 0), ""); +_Static_assert(__atomic_always_lock_free(2, 0), ""); +_Static_assert(!__atomic_always_lock_free(3, 0), ""); +_Static_assert(__atomic_always_lock_free(4, 0), ""); +_Static_assert(__atomic_always_lock_free(8, 0), ""); +_Static_assert(!__atomic_always_lock_free(16, 0), ""); +_Static_assert(!__atomic_always_lock_free(17, 0), ""); + +_Static_assert(__atomic_always_lock_free(1, incomplete), ""); +_Static_assert(!__atomic_always_lock_free(2, incomplete), ""); +_Static_assert(!__atomic_always_lock_free(4, incomplete), ""); + +_Static_assert(__atomic_always_lock_free(1, &i8), ""); +_Static_assert(__atomic_always_lock_free(1, &i64), ""); +_Static_assert(!__atomic_always_lock_free(2, &i8), ""); +_Static_assert(__atomic_always_lock_free(2, &i16), ""); +_Static_assert(__atomic_always_lock_free(2, &i64), ""); +_Static_assert(!__atomic_always_lock_free(4, &i16), ""); +_Static_assert(__atomic_always_lock_free(4, &i32), ""); +_Static_assert(__atomic_always_lock_free(4, &i64), ""); +_Static_assert(!__atomic_always_lock_free(8, &i32), ""); +_Static_assert(__atomic_always_lock_free(8, &i64), ""); + +void f(_Atomic(int) *i, _Atomic(int*) *p, _Atomic(float) *d, + int *I, int **P, float *D, struct S *s1, struct S *s2) { + __c11_atomic_init(I, 5); // expected-error {{pointer to _Atomic}} + __c11_atomic_load(0); // expected-error {{too few arguments to function}} + __c11_atomic_load(0,0,0); // expected-error {{too many arguments to function}} + __c11_atomic_store(0,0,0); // expected-error {{first argument to atomic builtin must be a pointer}} + __c11_atomic_store((int*)0,0,0); // expected-error {{first argument to atomic operation must be a pointer to _Atomic}} + + __c11_atomic_load(i, memory_order_seq_cst); + __c11_atomic_load(p, memory_order_seq_cst); + __c11_atomic_load(d, memory_order_seq_cst); + + int load_n_1 = __atomic_load_n(I, memory_order_relaxed); + int *load_n_2 = __atomic_load_n(P, memory_order_relaxed); + float load_n_3 = __atomic_load_n(D, memory_order_relaxed); // expected-error {{must be a pointer to integer or pointer}} + __atomic_load_n(s1, memory_order_relaxed); // expected-error {{must be a pointer to integer or pointer}} + + __atomic_load(i, I, memory_order_relaxed); // expected-error {{must be a pointer to a trivially-copyable type}} + __atomic_load(I, i, memory_order_relaxed); // expected-warning {{passing '_Atomic(int) *' to parameter of type 'int *'}} + __atomic_load(I, *P, memory_order_relaxed); + __atomic_load(I, *P, memory_order_relaxed, 42); // expected-error {{too many arguments}} + (int)__atomic_load(I, I, memory_order_seq_cst); // expected-error {{operand of type 'void'}} + __atomic_load(s1, s2, memory_order_acquire); + + __c11_atomic_store(i, 1, memory_order_seq_cst); + __c11_atomic_store(p, 1, memory_order_seq_cst); // expected-warning {{incompatible integer to pointer conversion}} + (int)__c11_atomic_store(d, 1, memory_order_seq_cst); // expected-error {{operand of type 'void'}} + + __atomic_store_n(I, 4, memory_order_release); + __atomic_store_n(I, 4.0, memory_order_release); + __atomic_store_n(I, P, memory_order_release); // expected-warning {{parameter of type 'int'}} + __atomic_store_n(i, 1, memory_order_release); // expected-error {{must be a pointer to integer or pointer}} + __atomic_store_n(s1, *s2, memory_order_release); // expected-error {{must be a pointer to integer or pointer}} + + __atomic_store(I, *P, memory_order_release); + __atomic_store(s1, s2, memory_order_release); + __atomic_store(i, I, memory_order_release); // expected-error {{trivially-copyable}} + + int exchange_1 = __c11_atomic_exchange(i, 1, memory_order_seq_cst); + int exchange_2 = __c11_atomic_exchange(I, 1, memory_order_seq_cst); // expected-error {{must be a pointer to _Atomic}} + int exchange_3 = __atomic_exchange_n(i, 1, memory_order_seq_cst); // expected-error {{must be a pointer to integer or pointer}} + int exchange_4 = __atomic_exchange_n(I, 1, memory_order_seq_cst); + + __atomic_exchange(s1, s2, s2, memory_order_seq_cst); + __atomic_exchange(s1, I, P, memory_order_seq_cst); // expected-warning 2{{parameter of type 'struct S *'}} + (int)__atomic_exchange(s1, s2, s2, memory_order_seq_cst); // expected-error {{operand of type 'void'}} + + __c11_atomic_fetch_add(i, 1, memory_order_seq_cst); + __c11_atomic_fetch_add(p, 1, memory_order_seq_cst); + __c11_atomic_fetch_add(d, 1, memory_order_seq_cst); // expected-error {{must be a pointer to atomic integer or pointer}} + + __atomic_fetch_add(i, 3, memory_order_seq_cst); // expected-error {{pointer to integer or pointer}} + __atomic_fetch_sub(I, 3, memory_order_seq_cst); + __atomic_fetch_sub(P, 3, memory_order_seq_cst); + __atomic_fetch_sub(D, 3, memory_order_seq_cst); // expected-error {{must be a pointer to integer or pointer}} + __atomic_fetch_sub(s1, 3, memory_order_seq_cst); // expected-error {{must be a pointer to integer or pointer}} + + __c11_atomic_fetch_and(i, 1, memory_order_seq_cst); + __c11_atomic_fetch_and(p, 1, memory_order_seq_cst); // expected-error {{must be a pointer to atomic integer}} + __c11_atomic_fetch_and(d, 1, memory_order_seq_cst); // expected-error {{must be a pointer to atomic integer}} + + __atomic_fetch_and(i, 3, memory_order_seq_cst); // expected-error {{pointer to integer}} + __atomic_fetch_or(I, 3, memory_order_seq_cst); + __atomic_fetch_xor(P, 3, memory_order_seq_cst); // expected-error {{must be a pointer to integer}} + __atomic_fetch_or(D, 3, memory_order_seq_cst); // expected-error {{must be a pointer to integer}} + __atomic_fetch_and(s1, 3, memory_order_seq_cst); // expected-error {{must be a pointer to integer}} + + _Bool cmpexch_1 = __c11_atomic_compare_exchange_strong(i, 0, 1, memory_order_seq_cst, memory_order_seq_cst); + _Bool cmpexch_2 = __c11_atomic_compare_exchange_strong(p, 0, (int*)1, memory_order_seq_cst, memory_order_seq_cst); + _Bool cmpexch_3 = __c11_atomic_compare_exchange_strong(d, (int*)0, 1, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{incompatible pointer types}} + + _Bool cmpexch_4 = __atomic_compare_exchange_n(I, I, 5, 1, memory_order_seq_cst, memory_order_seq_cst); + _Bool cmpexch_5 = __atomic_compare_exchange_n(I, P, 5, 0, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{; dereference with *}} + _Bool cmpexch_6 = __atomic_compare_exchange_n(I, I, P, 0, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{passing 'int **' to parameter of type 'int'}} + + _Bool cmpexch_7 = __atomic_compare_exchange(I, I, 5, 1, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{passing 'int' to parameter of type 'int *'}} + _Bool cmpexch_8 = __atomic_compare_exchange(I, P, I, 0, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{; dereference with *}} + _Bool cmpexch_9 = __atomic_compare_exchange(I, I, I, 0, memory_order_seq_cst, memory_order_seq_cst); + + const volatile int flag_k = 0; + volatile int flag = 0; + (void)(int)__atomic_test_and_set(&flag_k, memory_order_seq_cst); // expected-warning {{passing 'const volatile int *' to parameter of type 'volatile void *'}} + (void)(int)__atomic_test_and_set(&flag, memory_order_seq_cst); + __atomic_clear(&flag_k, memory_order_seq_cst); // expected-warning {{passing 'const volatile int *' to parameter of type 'volatile void *'}} + __atomic_clear(&flag, memory_order_seq_cst); + (int)__atomic_clear(&flag, memory_order_seq_cst); // expected-error {{operand of type 'void'}} +} diff --git a/clang/test/Sema/atomic-type.c b/clang/test/Sema/atomic-type.c new file mode 100644 index 0000000..a4ac552 --- /dev/null +++ b/clang/test/Sema/atomic-type.c @@ -0,0 +1,22 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only + +// Basic parsing/Sema tests for _Atomic +// No operations are actually supported on objects of this type yet. +// The qualifier syntax is not supported yet. +_Atomic(int) t1; +_Atomic(int) *t2 = &t1; +void testf(void*); +void f(void) { + _Atomic(_Atomic(int)*) t3; + _Atomic(_Atomic(int)*) *t4[2] = { &t3, 0 }; + testf(t4); +} +extern _Atomic(int (*)(int(*)[], int(*)[10])) mergetest; +extern _Atomic(int (*)(int(*)[10], int(*)[])) mergetest; +extern _Atomic(int (*)(int(*)[10], int(*)[10])) mergetest; + +_Atomic(int()) error1; // expected-error {{_Atomic cannot be applied to function type}} +_Atomic(struct ErrorS) error2; // expected-error {{_Atomic cannot be applied to incomplete type}} expected-note {{forward declaration}} +_Atomic(int[10]) error3; // expected-error {{_Atomic cannot be applied to array type}} +_Atomic(const int) error4; // expected-error {{_Atomic cannot be applied to qualified type}} +_Atomic(_Atomic(int)) error5; // expected-error {{_Atomic cannot be applied to atomic type}} diff --git a/clang/test/Sema/attr-alias.c b/clang/test/Sema/attr-alias.c new file mode 100644 index 0000000..151052f --- /dev/null +++ b/clang/test/Sema/attr-alias.c @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin -fsyntax-only -verify %s + +void g() {} + +// It is important that the following string be in the error message. The gcc +// testsuite looks for it to decide if a target supports aliases. + +void f() __attribute__((alias("g"))); //expected-error {{only weak aliases are supported}} diff --git a/clang/test/Sema/attr-aligned.c b/clang/test/Sema/attr-aligned.c new file mode 100644 index 0000000..c094ff1 --- /dev/null +++ b/clang/test/Sema/attr-aligned.c @@ -0,0 +1,38 @@ +// RUN: %clang_cc1 -triple i386-apple-darwin9 -fsyntax-only -verify %s + +int x __attribute__((aligned(3))); // expected-error {{requested alignment is not a power of 2}} + +// PR3254 +short g0[3] __attribute__((aligned)); +short g0_chk[__alignof__(g0) == 16 ? 1 : -1]; + +// <rdar://problem/6840045> +typedef char ueber_aligned_char __attribute__((aligned(8))); + +struct struct_with_ueber_char { + ueber_aligned_char c; +}; + +char a = 0; + +char a0[__alignof__(ueber_aligned_char) == 8? 1 : -1] = { 0 }; +char a1[__alignof__(struct struct_with_ueber_char) == 8? 1 : -1] = { 0 }; +char a2[__alignof__(a) == 1? : -1] = { 0 }; +char a3[sizeof(a) == 1? : -1] = { 0 }; + +// rdar://problem/8335865 +int b __attribute__((aligned(2))); +char b1[__alignof__(b) == 2 ?: -1] = {0}; + +struct C { int member __attribute__((aligned(2))); } c; +char c1[__alignof__(c) == 4 ?: -1] = {0}; +char c2[__alignof__(c.member) == 4 ?: -1] = {0}; + +struct D { int member __attribute__((aligned(2))) __attribute__((packed)); } d; +char d1[__alignof__(d) == 2 ?: -1] = {0}; +char d2[__alignof__(d.member) == 2 ?: -1] = {0}; + +struct E { int member __attribute__((aligned(2))); } __attribute__((packed)); +struct E e; +char e1[__alignof__(e) == 2 ?: -1] = {0}; +char e2[__alignof__(e.member) == 2 ?: -1] = {0}; diff --git a/clang/test/Sema/attr-args.c b/clang/test/Sema/attr-args.c new file mode 100644 index 0000000..6135801 --- /dev/null +++ b/clang/test/Sema/attr-args.c @@ -0,0 +1,40 @@ +// RUN: %clang_cc1 -DATTR=noreturn -verify -Wunused -Wused-but-marked-unused -Wunused-parameter -Wunused -fsyntax-only %s +// RUN: %clang_cc1 -DATTR=always_inline -verify -Wunused -Wused-but-marked-unused -Wunused-parameter -Wunused -fsyntax-only %s +// RUN: %clang_cc1 -DATTR=cdecl -verify -Wunused -Wused-but-marked-unused -Wunused-parameter -Wunused -fsyntax-only %s +// RUN: %clang_cc1 -DATTR=const -verify -Wunused -Wused-but-marked-unused -Wunused-parameter -Wunused -fsyntax-only %s +// RUN: %clang_cc1 -DATTR=fastcall -verify -Wunused -Wused-but-marked-unused -Wunused-parameter -Wunused -fsyntax-only %s +// RUN: %clang_cc1 -DATTR=malloc -verify -Wunused -Wused-but-marked-unused -Wunused-parameter -Wunused -fsyntax-only %s +// RUN: %clang_cc1 -DATTR=nothrow -verify -Wunused -Wused-but-marked-unused -Wunused-parameter -Wunused -fsyntax-only %s +// RUN: %clang_cc1 -DATTR=stdcall -verify -Wunused -Wused-but-marked-unused -Wunused-parameter -Wunused -fsyntax-only %s +// RUN: %clang_cc1 -DATTR=used -verify -Wunused -Wused-but-marked-unused -Wunused-parameter -Wunused -fsyntax-only %s +// RUN: %clang_cc1 -DATTR=unused -verify -Wunused -Wused-but-marked-unused -Wunused-parameter -Wunused -fsyntax-only %s +// RUN: %clang_cc1 -DATTR=weak -verify -Wunused -Wused-but-marked-unused -Wunused-parameter -Wunused -fsyntax-only %s + +#define ATTR_DECL(a) __attribute__((ATTR(a))) + +int a; + +inline ATTR_DECL(a) void* foo(); // expected-error{{attribute takes no arguments}} + + + +// RUN: %clang_cc1 -DATTR=noreturn -verify -Wunused -Wused-but-marked-unused -Wunused-parameter -Wunused -fsyntax-only %s +// RUN: %clang_cc1 -DATTR=always_inline -verify -Wunused -Wused-but-marked-unused -Wunused-parameter -Wunused -fsyntax-only %s +// RUN: %clang_cc1 -DATTR=cdecl -verify -Wunused -Wused-but-marked-unused -Wunused-parameter -Wunused -fsyntax-only %s +// RUN: %clang_cc1 -DATTR=const -verify -Wunused -Wused-but-marked-unused -Wunused-parameter -Wunused -fsyntax-only %s +// RUN: %clang_cc1 -DATTR=fastcall -verify -Wunused -Wused-but-marked-unused -Wunused-parameter -Wunused -fsyntax-only %s +// RUN: %clang_cc1 -DATTR=malloc -verify -Wunused -Wused-but-marked-unused -Wunused-parameter -Wunused -fsyntax-only %s +// RUN: %clang_cc1 -DATTR=nothrow -verify -Wunused -Wused-but-marked-unused -Wunused-parameter -Wunused -fsyntax-only %s +// RUN: %clang_cc1 -DATTR=stdcall -verify -Wunused -Wused-but-marked-unused -Wunused-parameter -Wunused -fsyntax-only %s +// RUN: %clang_cc1 -DATTR=used -verify -Wunused -Wused-but-marked-unused -Wunused-parameter -Wunused -fsyntax-only %s +// RUN: %clang_cc1 -DATTR=unused -verify -Wunused -Wused-but-marked-unused -Wunused-parameter -Wunused -fsyntax-only %s +// RUN: %clang_cc1 -DATTR=weak -verify -Wunused -Wused-but-marked-unused -Wunused-parameter -Wunused -fsyntax-only %s + +#define ATTR_DECL(a) __attribute__((ATTR(a))) + +int a; + +inline ATTR_DECL(a) void* foo(); // expected-error{{attribute takes no arguments}} + + + diff --git a/clang/test/Sema/attr-availability-ios.c b/clang/test/Sema/attr-availability-ios.c new file mode 100644 index 0000000..ea05e17 --- /dev/null +++ b/clang/test/Sema/attr-availability-ios.c @@ -0,0 +1,21 @@ +// RUN: %clang_cc1 "-triple" "x86_64-apple-ios3.0" -fsyntax-only -verify %s + +void f0(int) __attribute__((availability(ios,introduced=2.0,deprecated=2.1))); +void f1(int) __attribute__((availability(ios,introduced=2.1))); +void f2(int) __attribute__((availability(ios,introduced=2.0,deprecated=3.0))); +void f3(int) __attribute__((availability(ios,introduced=3.0))); +void f4(int) __attribute__((availability(macosx,introduced=10.1,deprecated=10.3,obsoleted=10.5), availability(ios,introduced=2.0,deprecated=2.1,obsoleted=3.0))); // expected-note{{explicitly marked unavailable}} + +void f5(int) __attribute__((availability(ios,introduced=2.0))) __attribute__((availability(ios,deprecated=3.0))); +void f6(int) __attribute__((availability(ios,deprecated=3.0))); +void f6(int) __attribute__((availability(ios,introduced=2.0))); + +void test() { + f0(0); // expected-warning{{'f0' is deprecated: first deprecated in iOS 2.1}} + f1(0); + f2(0); // expected-warning{{'f2' is deprecated: first deprecated in iOS 3.0}} + f3(0); + f4(0); // expected-error{{f4' is unavailable: obsoleted in iOS 3.0}} + f5(0); // expected-warning{{'f5' is deprecated: first deprecated in iOS 3.0}} + f6(0); // expected-warning{{'f6' is deprecated: first deprecated in iOS 3.0}} +} diff --git a/clang/test/Sema/attr-availability-macosx.c b/clang/test/Sema/attr-availability-macosx.c new file mode 100644 index 0000000..1de26e9 --- /dev/null +++ b/clang/test/Sema/attr-availability-macosx.c @@ -0,0 +1,31 @@ +// RUN: %clang_cc1 "-triple" "x86_64-apple-darwin9.0.0" -fsyntax-only -verify %s + +void f0(int) __attribute__((availability(macosx,introduced=10.4,deprecated=10.6))); +void f1(int) __attribute__((availability(macosx,introduced=10.5))); +void f2(int) __attribute__((availability(macosx,introduced=10.4,deprecated=10.5))); +void f3(int) __attribute__((availability(macosx,introduced=10.6))); +void f4(int) __attribute__((availability(macosx,introduced=10.1,deprecated=10.3,obsoleted=10.5), availability(ios,introduced=2.0,deprecated=3.0))); // expected-note{{explicitly marked unavailable}} +void f5(int) __attribute__((availability(ios,introduced=3.2), availability(macosx,unavailable))); // expected-note{{function has been explicitly marked unavailable here}} + +void test() { + f0(0); + f1(0); + f2(0); // expected-warning{{'f2' is deprecated: first deprecated in Mac OS X 10.5}} + f3(0); + f4(0); // expected-error{{f4' is unavailable: obsoleted in Mac OS X 10.5}} + f5(0); // expected-error{{'f5' is unavailable: not available on Mac OS X}} +} + +// rdar://10535640 + +enum { + foo __attribute__((availability(macosx,introduced=8.0,deprecated=9.0))) +}; + +enum { + bar __attribute__((availability(macosx,introduced=8.0,deprecated=9.0))) = foo +}; + +enum __attribute__((availability(macosx,introduced=8.0,deprecated=9.0))) { + bar1 = foo +}; diff --git a/clang/test/Sema/attr-availability.c b/clang/test/Sema/attr-availability.c new file mode 100644 index 0000000..0e6ea96 --- /dev/null +++ b/clang/test/Sema/attr-availability.c @@ -0,0 +1,26 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin9 -fsyntax-only -verify %s + +void f0() __attribute__((availability(macosx,introduced=10.4,deprecated=10.2))); // expected-warning{{feature cannot be deprecated in Mac OS X version 10.2 before it was introduced in version 10.4; attribute ignored}} +void f1() __attribute__((availability(ios,obsoleted=2.1,deprecated=3.0))); // expected-warning{{feature cannot be obsoleted in iOS version 2.1 before it was deprecated in version 3.0; attribute ignored}} +void f2() __attribute__((availability(ios,introduced=2.1,deprecated=2.1))); + +void f3() __attribute__((availability(otheros,introduced=2.2))); // expected-warning{{unknown platform 'otheros' in availability macro}} + +// rdar://10095131 +extern void +ATSFontGetName(const char *oName) __attribute__((availability(macosx,introduced=8.0,deprecated=9.0, message="use CTFontCopyFullName"))); + +extern void +ATSFontGetPostScriptName(int flags) __attribute__((availability(macosx,introduced=8.0,obsoleted=9.0, message="use ATSFontGetFullPostScriptName"))); // expected-note {{function has been explicitly marked unavailable here}} + +void test_10095131() { + ATSFontGetName("Hello"); // expected-warning {{'ATSFontGetName' is deprecated: first deprecated in Mac OS X 9.0 - use CTFontCopyFullName}} + ATSFontGetPostScriptName(100); // expected-error {{'ATSFontGetPostScriptName' is unavailable: obsoleted in Mac OS X 9.0 - use ATSFontGetFullPostScriptName}} +} + +// rdar://10711037 +__attribute__((availability(macos, unavailable))) // expected-warning {{attribute 'availability' is ignored}} +enum { + NSDataWritingFileProtectionWriteOnly = 0x30000000, + NSDataWritingFileProtectionCompleteUntilUserAuthentication = 0x40000000, +}; diff --git a/clang/test/Sema/attr-cleanup.c b/clang/test/Sema/attr-cleanup.c new file mode 100644 index 0000000..59ebbfc --- /dev/null +++ b/clang/test/Sema/attr-cleanup.c @@ -0,0 +1,40 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only + +void c1(int *a); + +extern int g1 __attribute((cleanup(c1))); // expected-warning {{cleanup attribute ignored}} +int g2 __attribute((cleanup(c1))); // expected-warning {{cleanup attribute ignored}} +static int g3 __attribute((cleanup(c1))); // expected-warning {{cleanup attribute ignored}} + +void t1() +{ + int v1 __attribute((cleanup)); // expected-error {{attribute takes one argument}} + int v2 __attribute((cleanup(1, 2))); // expected-error {{attribute takes one argument}} + + static int v3 __attribute((cleanup(c1))); // expected-warning {{cleanup attribute ignored}} + + int v4 __attribute((cleanup(h))); // expected-error {{'cleanup' argument 'h' not found}} + + int v5 __attribute((cleanup(c1))); + int v6 __attribute((cleanup(v3))); // expected-error {{'cleanup' argument 'v3' is not a function}} +} + +struct s { + int a, b; +}; + +void c2(); +void c3(struct s a); + +void t2() +{ + int v1 __attribute__((cleanup(c2))); // expected-error {{'cleanup' function 'c2' must take 1 parameter}} + int v2 __attribute__((cleanup(c3))); // expected-error {{'cleanup' function 'c3' parameter has type 'struct s' which is incompatible with type 'int *'}} +} + +// This is a manufactured testcase, but gcc accepts it... +void c4(_Bool a); +void t4() { + __attribute((cleanup(c4))) void* g; +} + diff --git a/clang/test/Sema/attr-decl-after-definition.c b/clang/test/Sema/attr-decl-after-definition.c new file mode 100644 index 0000000..4d32e00 --- /dev/null +++ b/clang/test/Sema/attr-decl-after-definition.c @@ -0,0 +1,19 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +void foo(); +void foo() __attribute__((unused)); +void foo() __attribute__((unused)); +void foo(){} // expected-note {{previous definition is here}} +void foo() __attribute__((constructor)); // expected-warning {{must precede definition}} +void foo(); + +int bar; +extern int bar; +int bar; +int bar __attribute__((weak)); +int bar __attribute__((used)); +extern int bar __attribute__((weak)); +int bar = 0; // expected-note {{previous definition is here}} +int bar __attribute__((weak)); // expected-warning {{must precede definition}} +int bar; + diff --git a/clang/test/Sema/attr-declspec-ignored.c b/clang/test/Sema/attr-declspec-ignored.c new file mode 100644 index 0000000..6fd35c0 --- /dev/null +++ b/clang/test/Sema/attr-declspec-ignored.c @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only + +__attribute__((visibility("hidden"))) __attribute__((aligned)) struct A; // expected-warning{{attribute 'visibility' is ignored, place it after "struct" to apply attribute to type declaration}} \ +// expected-warning{{attribute 'aligned' is ignored, place it after "struct" to apply attribute to type declaration}} +__attribute__((visibility("hidden"))) __attribute__((aligned)) union B; // expected-warning{{attribute 'visibility' is ignored, place it after "union" to apply attribute to type declaration}} \ +// expected-warning{{attribute 'aligned' is ignored, place it after "union" to apply attribute to type declaration}} +__attribute__((visibility("hidden"))) __attribute__((aligned)) enum C {C}; // expected-warning{{attribute 'visibility' is ignored, place it after "enum" to apply attribute to type declaration}} \ +// expected-warning{{attribute 'aligned' is ignored, place it after "enum" to apply attribute to type declaration}} + +__attribute__((visibility("hidden"))) __attribute__((aligned)) struct D {} d; +__attribute__((visibility("hidden"))) __attribute__((aligned)) union E {} e; +__attribute__((visibility("hidden"))) __attribute__((aligned)) enum F {F} f; diff --git a/clang/test/Sema/attr-deprecated-message.c b/clang/test/Sema/attr-deprecated-message.c new file mode 100644 index 0000000..5de31d0 --- /dev/null +++ b/clang/test/Sema/attr-deprecated-message.c @@ -0,0 +1,31 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only +// rdar: // 6734520 + +typedef int INT1 __attribute__((deprecated("Please avoid INT1"))); + +typedef INT1 INT2 __attribute__ ((__deprecated__("Please avoid INT2"))); + +typedef INT1 INT1a; // expected-warning {{'INT1' is deprecated: Please avoid INT1}} + +typedef INT1 INT1b __attribute__ ((deprecated("Please avoid INT1b"))); + +INT1 should_be_unavailable; // expected-warning {{'INT1' is deprecated: Please avoid INT1}} +INT1a should_not_be_deprecated; + +INT1 f1(void) __attribute__ ((deprecated("Please avoid f1"))); +INT1 f2(void); // expected-warning {{'INT1' is deprecated: Please avoid INT1}} + +typedef enum {red, green, blue} Color __attribute__((deprecated("Please avoid Color"))); + + +Color c1; // expected-warning {{'Color' is deprecated: Please avoid Color}} + +int g1; +int g2 __attribute__ ((deprecated("Please avoid g2"))); + +int func1() +{ + int (*pf)() = f1; // expected-warning {{'f1' is deprecated: Please avoid f1}} + int i = f2(); + return g1 + g2; // expected-warning {{'g2' is deprecated: Please avoid g2}} +} diff --git a/clang/test/Sema/attr-deprecated.c b/clang/test/Sema/attr-deprecated.c new file mode 100644 index 0000000..4760dab --- /dev/null +++ b/clang/test/Sema/attr-deprecated.c @@ -0,0 +1,115 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only + +int f() __attribute__((deprecated)); +void g() __attribute__((deprecated)); +void g(); + +extern int var __attribute__((deprecated)); + +int a() { + int (*ptr)() = f; // expected-warning {{'f' is deprecated}} + f(); // expected-warning {{'f' is deprecated}} + + // test if attributes propagate to functions + g(); // expected-warning {{'g' is deprecated}} + + return var; // expected-warning {{'var' is deprecated}} +} + +// test if attributes propagate to variables +extern int var; +int w() { + return var; // expected-warning {{'var' is deprecated}} +} + +int old_fn() __attribute__ ((deprecated)); +int old_fn(); +int (*fn_ptr)() = old_fn; // expected-warning {{'old_fn' is deprecated}} + +int old_fn() { + return old_fn()+1; // no warning, deprecated functions can use deprecated symbols. +} + + +struct foo { + int x __attribute__((deprecated)); +}; + +void test1(struct foo *F) { + ++F->x; // expected-warning {{'x' is deprecated}} + struct foo f1 = { .x = 17 }; // expected-warning {{'x' is deprecated}} + struct foo f2 = { 17 }; // expected-warning {{'x' is deprecated}} +} + +typedef struct foo foo_dep __attribute__((deprecated)); +foo_dep *test2; // expected-warning {{'foo_dep' is deprecated}} + +struct __attribute__((deprecated, + invalid_attribute)) bar_dep ; // expected-warning {{unknown attribute 'invalid_attribute' ignored}} + +struct bar_dep *test3; // expected-warning {{'bar_dep' is deprecated}} + + +// These should not warn because the actually declaration itself is deprecated. +// rdar://6756623 +foo_dep *test4 __attribute__((deprecated)); +struct bar_dep *test5 __attribute__((deprecated)); + +typedef foo_dep test6(struct bar_dep*); // expected-warning {{'foo_dep' is deprecated}} \ + // expected-warning {{'bar_dep' is deprecated}} +typedef foo_dep test7(struct bar_dep*) __attribute__((deprecated)); + +int test8(char *p) { + p += sizeof(foo_dep); // expected-warning {{'foo_dep' is deprecated}} + + foo_dep *ptr; // expected-warning {{'foo_dep' is deprecated}} + ptr = (foo_dep*) p; // expected-warning {{'foo_dep' is deprecated}} + + int func(foo_dep *foo); // expected-warning {{'foo_dep' is deprecated}} + return func(ptr); +} + +foo_dep *test9(void) __attribute__((deprecated)); +foo_dep *test9(void) { + void* myalloc(unsigned long); + + foo_dep *ptr + = (foo_dep*) + myalloc(sizeof(foo_dep)); + return ptr; +} + +void test10(void) __attribute__((deprecated)); +void test10(void) { + if (sizeof(foo_dep) == sizeof(void*)) { + } + foo_dep *localfunc(void); + foo_dep localvar; +} + +char test11[sizeof(foo_dep)] __attribute__((deprecated)); +char test12[sizeof(foo_dep)]; // expected-warning {{'foo_dep' is deprecated}} + +int test13(foo_dep *foo) __attribute__((deprecated)); +int test14(foo_dep *foo); // expected-warning {{'foo_dep' is deprecated}} + +unsigned long test15 = sizeof(foo_dep); // expected-warning {{'foo_dep' is deprecated}} +unsigned long test16 __attribute__((deprecated)) + = sizeof(foo_dep); + +foo_dep test17, // expected-warning {{'foo_dep' is deprecated}} + test18 __attribute__((deprecated)), + test19; + +// rdar://problem/8518751 +enum __attribute__((deprecated)) Test20 { + test20_a __attribute__((deprecated)), + test20_b +}; +void test20() { + enum Test20 f; // expected-warning {{'Test20' is deprecated}} + f = test20_a; // expected-warning {{'test20_a' is deprecated}} + f = test20_b; // expected-warning {{'test20_b' is deprecated}} +} + +char test21[__has_feature(attribute_deprecated_with_message) ? 1 : -1]; diff --git a/clang/test/Sema/attr-format.c b/clang/test/Sema/attr-format.c new file mode 100644 index 0000000..a223e08 --- /dev/null +++ b/clang/test/Sema/attr-format.c @@ -0,0 +1,80 @@ +//RUN: %clang_cc1 -fsyntax-only -verify %s + +#include <stdarg.h> + +void a(const char *a, ...) __attribute__((format(printf, 1,2))); // no-error +void b(const char *a, ...) __attribute__((format(printf, 1,1))); // expected-error {{'format' attribute parameter 3 is out of bounds}} +void c(const char *a, ...) __attribute__((format(printf, 0,2))); // expected-error {{'format' attribute parameter 2 is out of bounds}} +void d(const char *a, int c) __attribute__((format(printf, 1,2))); // expected-error {{format attribute requires variadic function}} +void e(char *str, int c, ...) __attribute__((format(printf, 2,3))); // expected-error {{format argument not a string type}} + +typedef const char* xpto; +void f(xpto c, va_list list) __attribute__((format(printf, 1, 0))); // no-error +void g(xpto c) __attribute__((format(printf, 1, 0))); // no-error + +void y(char *str) __attribute__((format(strftime, 1,0))); // no-error +void z(char *str, int c, ...) __attribute__((format(strftime, 1,2))); // expected-error {{strftime format attribute requires 3rd parameter to be 0}} + +int (*f_ptr)(char*,...) __attribute__((format(printf, 1,2))); // no-error +int (*f2_ptr)(double,...) __attribute__((format(printf, 1, 2))); // expected-error {{format argument not a string type}} + +struct _mystruct { + int (*printf)(const char *format, ...) __attribute__((__format__(printf, 1, 2))); // no-error + int (*printf2)(double format, ...) __attribute__((__format__(printf, 1, 2))); // expected-error {{format argument not a string type}} +}; + +typedef int (*f3_ptr)(char*,...) __attribute__((format(printf,1,0))); // no-error + +// <rdar://problem/6623513> +int rdar6623513(void *, const char*, const char*, ...) + __attribute__ ((format (printf, 3, 0))); + +int rdar6623513_aux(int len, const char* s) { + rdar6623513(0, "hello", "%.*s", len, s); +} + + + +// same as format(printf(...))... +void a2(const char *a, ...) __attribute__((format(printf0, 1,2))); // no-error +void b2(const char *a, ...) __attribute__((format(printf0, 1,1))); // expected-error {{'format' attribute parameter 3 is out of bounds}} +void c2(const char *a, ...) __attribute__((format(printf0, 0,2))); // expected-error {{'format' attribute parameter 2 is out of bounds}} +void d2(const char *a, int c) __attribute__((format(printf0, 1,2))); // expected-error {{format attribute requires variadic function}} +void e2(char *str, int c, ...) __attribute__((format(printf0, 2,3))); // expected-error {{format argument not a string type}} + +// FreeBSD usage +#define __printf0like(fmt,va) __attribute__((__format__(__printf0__,fmt,va))) +void null(int i, const char *a, ...) __printf0like(2,0); // no-error +void null(int i, const char *a, ...) { // expected-note{{passing argument to parameter 'a' here}} + if (a) + (void)0/* vprintf(...) would go here */; +} + +void callnull(void){ + null(0, 0); // no error + null(0, (char*)0); // no error + null(0, (void*)0); // no error + null(0, (int*)0); // expected-warning {{incompatible pointer types}} +} + + + +// PR4470 +int xx_vprintf(const char *, va_list); + +const char *foo(const char *format) __attribute__((format_arg(1))); + +void __attribute__((format(printf, 1, 0))) +foo2(const char *fmt, va_list va) { + xx_vprintf(foo(fmt), va); +} + +// PR6542 +extern void gcc_format (const char *, ...) + __attribute__ ((__format__(__gcc_diag__, 1, 2))); +extern void gcc_cformat (const char *, ...) + __attribute__ ((__format__(__gcc_cdiag__, 1, 2))); +extern void gcc_cxxformat (const char *, ...) + __attribute__ ((__format__(__gcc_cxxdiag__, 1, 2))); +extern void gcc_tformat (const char *, ...) + __attribute__ ((__format__(__gcc_tdiag__, 1, 2))); diff --git a/clang/test/Sema/attr-format_arg.c b/clang/test/Sema/attr-format_arg.c new file mode 100644 index 0000000..64a2387 --- /dev/null +++ b/clang/test/Sema/attr-format_arg.c @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +int printf(const char *, ...); + +const char* f(const char *s) __attribute__((format_arg(1))); + +void g(const char *s) { + printf("%d", 123); + printf("%d %d", 123); // expected-warning{{more '%' conversions than data arguments}} + + printf(f("%d"), 123); + printf(f("%d %d"), 123); // expected-warning{{more '%' conversions than data arguments}} +} diff --git a/clang/test/Sema/attr-malloc.c b/clang/test/Sema/attr-malloc.c new file mode 100644 index 0000000..2cec84d --- /dev/null +++ b/clang/test/Sema/attr-malloc.c @@ -0,0 +1,28 @@ +// RUN: %clang -Xclang -verify -fsyntax-only %s +// RUN: %clang -emit-llvm -S -o %t %s + +#include <stddef.h> + +// Declare malloc here explicitly so we don't depend on system headers. +void * malloc(size_t) __attribute((malloc)); + +int no_vars __attribute((malloc)); // expected-warning {{functions returning a pointer type}} + +void returns_void (void) __attribute((malloc)); // expected-warning {{functions returning a pointer type}} +int returns_int (void) __attribute((malloc)); // expected-warning {{functions returning a pointer type}} +int * returns_intptr(void) __attribute((malloc)); // no-warning +typedef int * iptr; +iptr returns_iptr (void) __attribute((malloc)); // no-warning + +__attribute((malloc)) void *(*f)(); // expected-warning{{'malloc' attribute only applies to functions returning a pointer type}} +__attribute((malloc)) int (*g)(); // expected-warning{{'malloc' attribute only applies to functions returning a pointer type}} + +__attribute((malloc)) +void * xalloc(unsigned n) { return malloc(n); } // no-warning +// RUN: grep 'define noalias .* @xalloc(' %t + +#define malloc_like __attribute((__malloc__)) +void * xalloc2(unsigned) malloc_like; +void * xalloc2(unsigned n) { return malloc(n); } +// RUN: grep 'define noalias .* @xalloc2(' %t + diff --git a/clang/test/Sema/attr-mode.c b/clang/test/Sema/attr-mode.c new file mode 100644 index 0000000..0c53362 --- /dev/null +++ b/clang/test/Sema/attr-mode.c @@ -0,0 +1,59 @@ +// RUN: %clang_cc1 -triple i686-pc-linux-gnu -DTEST_32BIT_X86 -fsyntax-only \ +// RUN: -verify %s +// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -DTEST_64BIT_X86 -fsyntax-only \ +// RUN: -verify %s + +typedef int i16_1 __attribute((mode(HI))); +int i16_1_test[sizeof(i16_1) == 2 ? 1 : -1]; +typedef int i16_2 __attribute((__mode__(__HI__))); +int i16_2_test[sizeof(i16_1) == 2 ? 1 : -1]; + +typedef float f64 __attribute((mode(DF))); +int f64_test[sizeof(f64) == 8 ? 1 : -1]; + +typedef int invalid_1 __attribute((mode)); // expected-error{{attribute requires unquoted parameter}} +typedef int invalid_2 __attribute((mode())); // expected-error{{attribute requires unquoted parameter}} +typedef int invalid_3 __attribute((mode(II))); // expected-error{{unknown machine mode}} +typedef struct {int i,j,k;} invalid_4 __attribute((mode(SI))); // expected-error{{mode attribute only supported for integer and floating-point types}} +typedef float invalid_5 __attribute((mode(SI))); // expected-error{{type of machine mode does not match type of base type}} + +int **__attribute((mode(QI)))* i32; // expected-error{{mode attribute}} + +typedef _Complex double c32 __attribute((mode(SC))); +int c32_test[sizeof(c32) == 8 ? 1 : -1]; +typedef _Complex float c64 __attribute((mode(DC))); +typedef _Complex float c80 __attribute((mode(XC))); + +// PR6108: Correctly select 'long' built in type on 64-bit platforms for 64 bit +// modes. Also test other mode-based conversions. +typedef int i8_mode_t __attribute__ ((__mode__ (__QI__))); +typedef unsigned int ui8_mode_t __attribute__ ((__mode__ (__QI__))); +typedef int i16_mode_t __attribute__ ((__mode__ (__HI__))); +typedef unsigned int ui16_mode_t __attribute__ ((__mode__ (__HI__))); +typedef int i32_mode_t __attribute__ ((__mode__ (__SI__))); +typedef unsigned int ui32_mode_t __attribute__ ((__mode__ (__SI__))); +typedef int i64_mode_t __attribute__ ((__mode__ (__DI__))); +typedef unsigned int ui64_mode_t __attribute__ ((__mode__ (__DI__))); +void f_i8_arg(i8_mode_t* x) { (void)x; } +void f_ui8_arg(ui8_mode_t* x) { (void)x; } +void f_i16_arg(i16_mode_t* x) { (void)x; } +void f_ui16_arg(ui16_mode_t* x) { (void)x; } +void f_i32_arg(i32_mode_t* x) { (void)x; } +void f_ui32_arg(ui32_mode_t* x) { (void)x; } +void f_i64_arg(i64_mode_t* x) { (void)x; } +void f_ui64_arg(ui64_mode_t* x) { (void)x; } +void test_char_to_i8(signed char* y) { f_i8_arg(y); } +void test_char_to_ui8(unsigned char* y) { f_ui8_arg(y); } +void test_short_to_i16(short* y) { f_i16_arg(y); } +void test_short_to_ui16(unsigned short* y) { f_ui16_arg(y); } +void test_int_to_i32(int* y) { f_i32_arg(y); } +void test_int_to_ui32(unsigned int* y) { f_ui32_arg(y); } +#if TEST_32BIT_X86 +void test_long_to_i64(long long* y) { f_i64_arg(y); } +void test_long_to_ui64(unsigned long long* y) { f_ui64_arg(y); } +#elif TEST_64BIT_X86 +void test_long_to_i64(long* y) { f_i64_arg(y); } +void test_long_to_ui64(unsigned long* y) { f_ui64_arg(y); } +#else +#error Unknown test architecture. +#endif diff --git a/clang/test/Sema/attr-naked.c b/clang/test/Sema/attr-naked.c new file mode 100644 index 0000000..d9fa542 --- /dev/null +++ b/clang/test/Sema/attr-naked.c @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only + +int a __attribute__((naked)); // expected-warning {{'naked' attribute only applies to functions}} + +__attribute__((naked)) int t0(void) { + __asm__ volatile("mov r0, #0"); +} + +void t1() __attribute__((naked)); + +void t2() __attribute__((naked(2))); // expected-error {{attribute takes no arguments}} + diff --git a/clang/test/Sema/attr-nodebug.c b/clang/test/Sema/attr-nodebug.c new file mode 100644 index 0000000..a66e961 --- /dev/null +++ b/clang/test/Sema/attr-nodebug.c @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only + +int a __attribute__((nodebug)); // expected-warning {{'nodebug' attribute only applies to functions}} + +void t1() __attribute__((nodebug)); + +void t2() __attribute__((nodebug(2))); // expected-error {{attribute takes no arguments}} + diff --git a/clang/test/Sema/attr-noinline.c b/clang/test/Sema/attr-noinline.c new file mode 100644 index 0000000..dfc88a8 --- /dev/null +++ b/clang/test/Sema/attr-noinline.c @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only + +int a __attribute__((noinline)); // expected-warning {{'noinline' attribute only applies to functions}} + +void t1() __attribute__((noinline)); + +void t2() __attribute__((noinline(2))); // expected-error {{attribute takes no arguments}} + diff --git a/clang/test/Sema/attr-noreturn.c b/clang/test/Sema/attr-noreturn.c new file mode 100644 index 0000000..5c643ff --- /dev/null +++ b/clang/test/Sema/attr-noreturn.c @@ -0,0 +1,44 @@ +// RUN: %clang_cc1 -verify -fsyntax-only %s + +static void (*fp0)(void) __attribute__((noreturn)); + +void fatal(); + +static void __attribute__((noreturn)) f0(void) { + fatal(); +} // expected-warning {{function declared 'noreturn' should not return}} + +// On K&R +int f1() __attribute__((noreturn)); + +int g0 __attribute__((noreturn)); // expected-warning {{'noreturn' only applies to function types; type here is 'int'}} + +int f2() __attribute__((noreturn(1, 2))); // expected-error {{attribute takes no arguments}} + +void f3() __attribute__((noreturn)); +void f3() { + return; // expected-warning {{function 'f3' declared 'noreturn' should not return}} +} + +#pragma clang diagnostic error "-Winvalid-noreturn" + +void f4() __attribute__((noreturn)); +void f4() { + return; // expected-error {{function 'f4' declared 'noreturn' should not return}} +} + +// PR4685 +extern void f5 (unsigned long) __attribute__ ((__noreturn__)); + +void +f5 (unsigned long size) +{ + +} + +// PR2461 +__attribute__((noreturn)) void f(__attribute__((noreturn)) void (*x)(void)) { + x(); +} + +typedef void (*Fun)(void) __attribute__ ((noreturn(2))); // expected-error {{attribute takes no arguments}} diff --git a/clang/test/Sema/attr-regparm.c b/clang/test/Sema/attr-regparm.c new file mode 100644 index 0000000..642c07e --- /dev/null +++ b/clang/test/Sema/attr-regparm.c @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -triple i386-apple-darwin9 -fsyntax-only -verify %s + +__attribute((regparm(2))) int x0(void); +__attribute((regparm(1.0))) int x1(void); // expected-error{{'regparm' attribute requires integer constant}} +__attribute((regparm(-1))) int x2(void); // expected-error{{'regparm' parameter must be between 0 and 3 inclusive}} +__attribute((regparm(5))) int x3(void); // expected-error{{'regparm' parameter must be between 0 and 3 inclusive}} +__attribute((regparm(5,3))) int x4(void); // expected-error{{attribute takes one argument}} + +void __attribute__((regparm(3))) x5(int); +void x5(int); // expected-note{{previous declaration is here}} +void __attribute__((regparm(2))) x5(int); // expected-error{{function declared with with regparm(2) attribute was previously declared with the regparm(3) attribute}} diff --git a/clang/test/Sema/attr-returns-twice.c b/clang/test/Sema/attr-returns-twice.c new file mode 100644 index 0000000..13f53e3 --- /dev/null +++ b/clang/test/Sema/attr-returns-twice.c @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only + +int a __attribute__((returns_twice)); // expected-warning {{'returns_twice' attribute only applies to functions}} + +__attribute__((returns_twice)) void t0(void) { +} + +void t1() __attribute__((returns_twice)); + +void t2() __attribute__((returns_twice(2))); // expected-error {{attribute takes no arguments}} + +typedef void (*t3)(void) __attribute__((returns_twice)); // expected-warning {{'returns_twice' attribute only applies to functions}} diff --git a/clang/test/Sema/attr-section.c b/clang/test/Sema/attr-section.c new file mode 100644 index 0000000..a932525 --- /dev/null +++ b/clang/test/Sema/attr-section.c @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -verify -fsyntax-only -triple x86_64-apple-darwin9 %s + +int x __attribute__((section( + 42))); // expected-error {{argument to section attribute was not a string literal}} + + +// rdar://4341926 +int y __attribute__((section( + "sadf"))); // expected-error {{mach-o section specifier requires a segment and section separated by a comma}} + +// PR6007 +void test() { + __attribute__((section("NEAR,x"))) int n1; // expected-error {{'section' attribute is not valid on local variables}} + __attribute__((section("NEAR,x"))) static int n2; // ok. +} diff --git a/clang/test/Sema/attr-sentinel.c b/clang/test/Sema/attr-sentinel.c new file mode 100644 index 0000000..abc108f --- /dev/null +++ b/clang/test/Sema/attr-sentinel.c @@ -0,0 +1,59 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +#define NULL (void*)0 + +#define ATTR __attribute__ ((__sentinel__)) + +void foo1 (int x, ...) ATTR; // expected-note 3 {{function has been explicitly marked sentinel here}} +void foo5 (int x, ...) __attribute__ ((__sentinel__(1))); // expected-note {{function has been explicitly marked sentinel here}} +void foo6 (int x, ...) __attribute__ ((__sentinel__(5))); // expected-note {{function has been explicitly marked sentinel here}} +void foo7 (int x, ...) __attribute__ ((__sentinel__(0))); // expected-note {{function has been explicitly marked sentinel here}} +void foo10 (int x, ...) __attribute__ ((__sentinel__(1,1))); +void foo12 (int x, ... ) ATTR; // expected-note {{function has been explicitly marked sentinel here}} + +#define FOOMACRO(...) foo1(__VA_ARGS__) + +void test1() { + foo1(1, NULL); // OK + foo1(1, 0) ; // expected-warning {{missing sentinel in function call}} + foo5(1, NULL, 2); // OK + foo5(1,2,NULL, 1); // OK + foo5(1, NULL, 2, 1); // expected-warning {{missing sentinel in function call}} + + foo6(1,2,3,4,5,6,7); // expected-warning {{missing sentinel in function call}} + foo6(1,NULL,3,4,5,6,7); // OK + foo7(1); // expected-warning {{not enough variable arguments in 'foo7' declaration to fit a sentinel}} + foo7(1, NULL); // OK + + foo12(1); // expected-warning {{not enough variable arguments in 'foo12' declaration to fit a sentinel}} + + // PR 5685 + struct A {}; + struct A a, b, c; + foo1(3, &a, &b, &c); // expected-warning {{missing sentinel in function call}} + foo1(3, &a, &b, &c, (struct A*) 0); + + // PR11002 + FOOMACRO(1, 2); // expected-warning {{missing sentinel in function call}} +} + + + +void (*e) (int arg, const char * format, ...) __attribute__ ((__sentinel__ (1,1))); + +void test2() { + void (*b) (int arg, const char * format, ...) __attribute__ ((__sentinel__)); // expected-note {{function has been explicitly marked sentinel here}} + void (*z) (int arg, const char * format, ...) __attribute__ ((__sentinel__ (2))); // expected-note {{function has been explicitly marked sentinel here}} + + + void (*y) (int arg, const char * format, ...) __attribute__ ((__sentinel__ (5))); // expected-note {{function has been explicitly marked sentinel here}} + + b(1, "%s", (void*)0); // OK + b(1, "%s", 0); // expected-warning {{missing sentinel in function call}} + z(1, "%s",4 ,1,0); // expected-warning {{missing sentinel in function call}} + z(1, "%s", (void*)0, 1, 0); // OK + + y(1, "%s", 1,2,3,4,5,6,7); // expected-warning {{missing sentinel in function call}} + + y(1, "%s", (void*)0,3,4,5,6,7); // OK +} diff --git a/clang/test/Sema/attr-unavailable-message.c b/clang/test/Sema/attr-unavailable-message.c new file mode 100644 index 0000000..b2956d8 --- /dev/null +++ b/clang/test/Sema/attr-unavailable-message.c @@ -0,0 +1,49 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +// rdar: //6734520 + +int foo(int) __attribute__((__unavailable__("USE IFOO INSTEAD"))); // expected-note {{function has been explicitly marked unavailable here}} +double dfoo(double) __attribute__((__unavailable__("NO LONGER"))); // expected-note 2 {{function has been explicitly marked unavailable here}} + +void bar() __attribute__((__unavailable__)); // expected-note {{explicitly marked unavailable}} + +void test_foo() { + int ir = foo(1); // expected-error {{'foo' is unavailable: USE IFOO INSTEAD}} + double dr = dfoo(1.0); // expected-error {{'dfoo' is unavailable: NO LONGER}} + + void (*fp)() = &bar; // expected-error {{'bar' is unavailable}} + + double (*fp4)(double) = dfoo; // expected-error {{'dfoo' is unavailable: NO LONGER}} +} + +char test2[__has_feature(attribute_unavailable_with_message) ? 1 : -1]; + +// rdar://9623855 +void unavail(void) __attribute__((__unavailable__)); +void unavail(void) { + // No complains inside an unavailable function. + int ir = foo(1); + double dr = dfoo(1.0); + void (*fp)() = &bar; + double (*fp4)(double) = dfoo; +} + +// rdar://10201690 +enum foo { + a = 1, + b __attribute__((deprecated())) = 2, + c = 3 +}__attribute__((deprecated())); + +enum fee { // expected-note {{declaration has been explicitly marked unavailable here}} + r = 1, // expected-note {{declaration has been explicitly marked unavailable here}} + s = 2, + t = 3 +}__attribute__((unavailable())); + +enum fee f() { // expected-error {{'fee' is unavailable}} + int i = a; // expected-warning {{'a' is deprecated}} + + i = b; // expected-warning {{'b' is deprecated}} + + return r; // expected-error {{'r' is unavailable}} +} diff --git a/clang/test/Sema/attr-unknown.c b/clang/test/Sema/attr-unknown.c new file mode 100644 index 0000000..d1a831d --- /dev/null +++ b/clang/test/Sema/attr-unknown.c @@ -0,0 +1,4 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wattributes %s + +int x __attribute__((foobar)); // expected-warning {{unknown attribute 'foobar' ignored}} +void z() __attribute__((bogusattr)); // expected-warning {{unknown attribute 'bogusattr' ignored}} diff --git a/clang/test/Sema/attr-unused.c b/clang/test/Sema/attr-unused.c new file mode 100644 index 0000000..07c65cb --- /dev/null +++ b/clang/test/Sema/attr-unused.c @@ -0,0 +1,43 @@ +// RUN: %clang_cc1 -verify -Wunused -Wused-but-marked-unused -Wunused-parameter -Wunused -fsyntax-only %s + +static void (*fp0)(void) __attribute__((unused)); + +static void __attribute__((unused)) f0(void); + +// On K&R +int f1() __attribute__((unused)); + +int g0 __attribute__((unused)); + +int f2() __attribute__((unused(1, 2))); // expected-error {{attribute takes no arguments}} + +struct Test0_unused {} __attribute__((unused)); +struct Test0_not_unused {}; +typedef int Int_unused __attribute__((unused)); +typedef int Int_not_unused; + +void test0() { + int x; // expected-warning {{unused variable}} + + Int_not_unused i0; // expected-warning {{unused variable}} + Int_unused i1; // expected-warning {{'Int_unused' was marked unused but was used}} + + struct Test0_not_unused s0; // expected-warning {{unused variable}} + struct Test0_unused s1; // expected-warning {{'Test0_unused' was marked unused but was used}} +} + +int f3(int x) { // expected-warning{{unused parameter 'x'}} + return 0; +} + +int f4(int x) { + return x; +} + +int f5(int x __attribute__((__unused__))) { + return 0; +} + +int f6(int x __attribute__((__unused__))) { + return x; // expected-warning{{'x' was marked unused but was used}} +} diff --git a/clang/test/Sema/attr-used.c b/clang/test/Sema/attr-used.c new file mode 100644 index 0000000..0838816 --- /dev/null +++ b/clang/test/Sema/attr-used.c @@ -0,0 +1,20 @@ +// RUN: %clang_cc1 -verify -fsyntax-only %s + +extern int l0 __attribute__((used)); // expected-warning {{used attribute ignored}} +__private_extern__ int l1 __attribute__((used)); // expected-warning {{used attribute ignored}} + +struct __attribute__((used)) s { // expected-warning {{'used' attribute only applies to variables and functions}} + int x; +}; + +int a __attribute__((used)); + +static void __attribute__((used)) f0(void) { +} + +void f1() { + static int a __attribute__((used)); + int b __attribute__((used)); // expected-warning {{used attribute ignored}} +} + + diff --git a/clang/test/Sema/attr-visibility.c b/clang/test/Sema/attr-visibility.c new file mode 100644 index 0000000..5cf2695 --- /dev/null +++ b/clang/test/Sema/attr-visibility.c @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify %s + +void test0() __attribute__((visibility("default"))); +void test1() __attribute__((visibility("hidden"))); +void test2() __attribute__((visibility("internal"))); + +// rdar://problem/10753392 +void test3() __attribute__((visibility("protected"))); // expected-warning {{target does not support 'protected' visibility; using 'default'}} + diff --git a/clang/test/Sema/attr-weak.c b/clang/test/Sema/attr-weak.c new file mode 100644 index 0000000..adedf12 --- /dev/null +++ b/clang/test/Sema/attr-weak.c @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 -verify -fsyntax-only %s + +extern int g0 __attribute__((weak)); +extern int g1 __attribute__((weak_import)); +int g2 __attribute__((weak)); +int g3 __attribute__((weak_import)); // expected-warning {{'weak_import' attribute cannot be specified on a definition}} +int __attribute__((weak_import)) g4(void); +void __attribute__((weak_import)) g5(void) { +} + +struct __attribute__((weak)) s0 {}; // expected-warning {{'weak' attribute only applies to variables and functions}} +struct __attribute__((weak_import)) s1 {}; // expected-warning {{'weak_import' attribute only applies to variables and functions}} + +static int x __attribute__((weak)); // expected-error {{weak declaration cannot have internal linkage}} + +// rdar://9538608 +int C; // expected-note {{previous definition is here}} +extern int C __attribute__((weak_import)); // expected-warning {{an already-declared variable is made a weak_import declaration}} diff --git a/clang/test/Sema/bitfield-layout.c b/clang/test/Sema/bitfield-layout.c new file mode 100644 index 0000000..2655fc7 --- /dev/null +++ b/clang/test/Sema/bitfield-layout.c @@ -0,0 +1,42 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify -triple=i686-apple-darwin9 + +#define CHECK_SIZE(kind, name, size) extern int name##1[sizeof(kind name) == size ? 1 : -1]; +#define CHECK_ALIGN(kind, name, size) extern int name##2[__alignof(kind name) == size ? 1 : -1]; + +// Zero-width bit-fields +struct a {char x; int : 0; char y;}; +CHECK_SIZE(struct, a, 5) +CHECK_ALIGN(struct, a, 1) + +union b {char x; int : 0; char y;}; +CHECK_SIZE(union, b, 1) +CHECK_ALIGN(union, b, 1) + +// Unnamed bit-field align +struct c {char x; int : 20;}; +CHECK_SIZE(struct, c, 4) +CHECK_ALIGN(struct, c, 1) + +union d {char x; int : 20;}; +CHECK_SIZE(union, d, 3) +CHECK_ALIGN(union, d, 1) + +// Bit-field packing +struct __attribute__((packed)) e {int x : 4, y : 30, z : 30;}; +CHECK_SIZE(struct, e, 8) +CHECK_ALIGN(struct, e, 1) + +// Alignment on bit-fields +struct f {__attribute((aligned(8))) int x : 30, y : 30, z : 30;}; +CHECK_SIZE(struct, f, 24) +CHECK_ALIGN(struct, f, 8) + +// Large structure (overflows i32, in bits). +struct s0 { + char a[0x32100000]; + int x:30, y:30; +}; + +CHECK_SIZE(struct, s0, 0x32100008) +CHECK_ALIGN(struct, s0, 4) + diff --git a/clang/test/Sema/bitfield-promote.c b/clang/test/Sema/bitfield-promote.c new file mode 100644 index 0000000..4d14ad1 --- /dev/null +++ b/clang/test/Sema/bitfield-promote.c @@ -0,0 +1,34 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +struct {unsigned x : 2;} x; +__typeof__((x.x+=1)+1) y; +__typeof__(x.x<<1) y; +int y; + + +struct { int x : 8; } x1; +long long y1; +__typeof__(((long long)x1.x + 1)) y1; + + +// Check for extensions: variously sized unsigned bit-fields fitting +// into a signed int promote to signed int. +enum E { ec1, ec2, ec3 }; +struct S { + enum E e : 2; + unsigned short us : 4; + unsigned long long ul1 : 8; + unsigned long long ul2 : 50; +} s; + +__typeof(s.e + s.e) x_e; +int x_e; + +__typeof(s.us + s.us) x_us; +int x_us; + +__typeof(s.ul1 + s.ul1) x_ul1; +int x_ul1; + +__typeof(s.ul2 + s.ul2) x_ul2; +unsigned long long x_ul2; + diff --git a/clang/test/Sema/bitfield.c b/clang/test/Sema/bitfield.c new file mode 100644 index 0000000..a1ce894 --- /dev/null +++ b/clang/test/Sema/bitfield.c @@ -0,0 +1,41 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify +enum e0; // expected-note{{forward declaration of 'enum e0'}} + +struct a { + int a : -1; // expected-error{{bit-field 'a' has negative width}} + + // rdar://6081627 + int b : 33; // expected-error{{size of bit-field 'b' (33 bits) exceeds size of its type (32 bits)}} + + int c : (1 + 0.25); // expected-error{{expression is not an integer constant expression}} + int d : (int)(1 + 0.25); + + // rdar://6138816 + int e : 0; // expected-error {{bit-field 'e' has zero width}} + + float xx : 4; // expected-error {{bit-field 'xx' has non-integral type}} + + // PR3607 + enum e0 f : 1; // expected-error {{field has incomplete type 'enum e0'}} + + int g : (_Bool)1; + + // PR4017 + char : 10; // expected-error {{size of anonymous bit-field (10 bits) exceeds size of its type (8 bits)}} + unsigned : -2; // expected-error {{anonymous bit-field has negative width (-2)}} + float : 12; // expected-error {{anonymous bit-field has non-integral type 'float'}} +}; + +struct b {unsigned x : 2;} x; +__typeof__(x.x+1) y; +int y; + +struct {unsigned x : 2;} x2; +__typeof__((x.x+=1)+1) y; +__typeof__((0,x.x)+1) y; +__typeof__(x.x<<1) y; +int y; + +struct PR8025 { + double : 2; // expected-error{{anonymous bit-field has non-integral type 'double'}} +}; diff --git a/clang/test/Sema/block-args.c b/clang/test/Sema/block-args.c new file mode 100644 index 0000000..5ee383e --- /dev/null +++ b/clang/test/Sema/block-args.c @@ -0,0 +1,47 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify -fblocks + +void take(void*); + +void test() { + take(^(int x){}); + take(^(int x, int y){}); + take(^(int x, int y){}); + take(^(int x, // expected-note {{previous declaration is here}} + int x){}); // expected-error {{redefinition of parameter 'x'}} + + + take(^(int x) { return x+1; }); + + int (^CP)(int) = ^(int x) { return x*x; }; + take(CP); + + int arg; + ^{return 1;}(); + ^{return 2;}(arg); // expected-error {{too many arguments to block call}} + ^(void){return 3;}(1); // expected-error {{too many arguments to block call}} + ^(){return 4;}(arg); // expected-error {{too many arguments to block call}} + ^(int x, ...){return 5;}(arg, arg); // Explicit varargs, ok. +} + +int main(int argc, char** argv) { + ^(int argCount) { + argCount = 3; + }(argc); +} + +// radar 7528255 +void f0() { + ^(int, double d, char) {}(1, 1.34, 'a'); // expected-error {{parameter name omitted}} \ + // expected-error {{parameter name omitted}} +} + +// rdar://problem/8962770 +void test4() { + int (^f)() = ^((x)) { }; // expected-error {{expected ')'}} expected-warning {{type specifier missing}} expected-note {{to match this}} +} + +// rdar://problem/9170609 +void test5_helper(void (^)(int, int[*])); +void test5(void) { + test5_helper(^(int n, int array[n]) {}); +} diff --git a/clang/test/Sema/block-call.c b/clang/test/Sema/block-call.c new file mode 100644 index 0000000..2aa1422 --- /dev/null +++ b/clang/test/Sema/block-call.c @@ -0,0 +1,52 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -fblocks + +int (*FP)(); +int (^IFP) (); +int (^II) (int); +int main() { + int (*FPL) (int) = FP; // C doesn't consider this an error. + + // For Blocks, the ASTContext::typesAreBlockCompatible() makes sure this is an error. + int (^PFR) (int) = IFP; // OK + PFR = II; // OK + + int (^IFP) () = PFR; // OK + + + const int (^CIC) () = IFP; // OK - initializing 'const int (^)()' with an expression of type 'int (^)()'}} + + const int (^CICC) () = CIC; + + + int * const (^IPCC) () = 0; + + int * const (^IPCC1) () = IPCC; + + int * (^IPCC2) () = IPCC; // expected-error {{incompatible block pointer types initializing 'int *(^)()' with an expression of type 'int *const (^)()'}} + + int (^IPCC3) (const int) = PFR; + + int (^IPCC4) (int, char (^CArg) (double)); + + int (^IPCC5) (int, char (^CArg) (double)) = IPCC4; + + int (^IPCC6) (int, char (^CArg) (float)) = IPCC4; // expected-error {{incompatible block pointer types initializing 'int (^)(int, char (^)(float))' with an expression of type 'int (^)(int, char (^)(double))'}} + + IPCC2 = 0; + IPCC2 = 1; // expected-error {{invalid block pointer conversion assigning to 'int *(^)()' from 'int'}} + int (^x)() = 0; + int (^y)() = 3; // expected-error {{invalid block pointer conversion initializing 'int (^)()' with an expression of type 'int'}} + int a = 1; + int (^z)() = a+4; // expected-error {{invalid block pointer conversion initializing 'int (^)()' with an expression of type 'int'}} +} + +int blah() { + int (^IFP) (float); + char (^PCP)(double, double, char); + + IFP(1.0); + IFP (1.0, 2.0); // expected-error {{too many arguments to block call}} + + char ch = PCP(1.0, 2.0, 'a'); + return PCP(1.0, 2.0); // expected-error {{too few arguments to block}} +} diff --git a/clang/test/Sema/block-explicit-noreturn-type.c b/clang/test/Sema/block-explicit-noreturn-type.c new file mode 100644 index 0000000..12f4f4f --- /dev/null +++ b/clang/test/Sema/block-explicit-noreturn-type.c @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify -fblocks +// rdar://10466373 + +typedef short SHORT; + +void f0() { + (void) ^{ + if (1) + return (float)1.0; + else if (2) + return (double)2.0; // expected-error {{return type 'double' must match previous return type 'float' when block literal has}} + else + return (SHORT)3; // expected-error {{return type 'SHORT' (aka 'short') must match previous return type 'float' when}} + }; +} diff --git a/clang/test/Sema/block-labels.c b/clang/test/Sema/block-labels.c new file mode 100644 index 0000000..d1b60cc --- /dev/null +++ b/clang/test/Sema/block-labels.c @@ -0,0 +1,27 @@ +// RUN: %clang_cc1 %s -verify -fblocks -fsyntax-only + +void xx(); + +int a() { + A: + + if (1) xx(); + return ^{ + A: return 1; + }(); +} +int b() { + A: return ^{int a; A:return 1;}(); +} + +int d() { + A: return ^{int a; A: a = ^{int a; A:return 1;}() + ^{int b; A:return 2;}(); return a; }(); +} + +int c() { + goto A; // expected-error {{use of undeclared label 'A'}} + return ^{ + A: + return 1; + }(); +} diff --git a/clang/test/Sema/block-literal.c b/clang/test/Sema/block-literal.c new file mode 100644 index 0000000..c303b84 --- /dev/null +++ b/clang/test/Sema/block-literal.c @@ -0,0 +1,89 @@ +// RUN: %clang_cc1 -fsyntax-only %s -verify -fblocks + +void I( void (^)(void)); +void (^noop)(void); + +void nothing(); +int printf(const char*, ...); + +typedef void (^T) (void); + +void takeblock(T); +int takeintint(int (^C)(int)) { return C(4); } + +T somefunction() { + if (^{ }) + nothing(); + + noop = ^{}; + + noop = ^{printf("\nClosure\n"); }; + + I(^{ }); + + return ^{printf("\nClosure\n"); }; +} +void test2() { + int x = 4; + + takeblock(^{ printf("%d\n", x); }); + + while (1) { + takeblock(^{ + break; // expected-error {{'break' statement not in loop or switch statement}} + continue; // expected-error {{'continue' statement not in loop statement}} + while(1) break; // ok + goto foo; // expected-error {{use of undeclared label 'foo'}} + a: goto a; // ok + }); + break; + } + + foo: + takeblock(^{ x = 4; }); // expected-error {{variable is not assignable (missing __block type specifier)}} + __block y = 7; // expected-warning {{type specifier missing, defaults to 'int'}} + takeblock(^{ y = 8; }); +} + + +void (^test3())(void) { + return ^{}; +} + +void test4() { + void (^noop)(void) = ^{}; + void (*noop2)() = 0; +} + +void myfunc(int (^block)(int)) {} + +void myfunc3(const int *x); + +void test5() { + int a; + + myfunc(^(int abcd) { + myfunc3(&a); + return 1; + }); +} + +void *X; + +void test_arguments() { + int y; + int (^c)(char); + (1 ? c : 0)('x'); + (1 ? 0 : c)('x'); + + (1 ? c : c)('x'); +} + +static int global_x = 10; +void (^global_block)(void) = ^{ printf("global x is %d\n", global_x); }; + +typedef void (^void_block_t)(void); + +static const void_block_t myBlock = ^{ }; + +static const void_block_t myBlock2 = ^ void(void) { }; diff --git a/clang/test/Sema/block-misc.c b/clang/test/Sema/block-misc.c new file mode 100644 index 0000000..2260458 --- /dev/null +++ b/clang/test/Sema/block-misc.c @@ -0,0 +1,228 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -fblocks +void donotwarn(); + +int (^IFP) (); +int (^II) (int); +int test1() { + int (^PFR) (int) = 0; // OK + PFR = II; // OK + + if (PFR == II) // OK + donotwarn(); + + if (PFR == IFP) // OK + donotwarn(); + + if (PFR == (int (^) (int))IFP) // OK + donotwarn(); + + if (PFR == 0) // OK + donotwarn(); + + if (PFR) // OK + donotwarn(); + + if (!PFR) // OK + donotwarn(); + + return PFR != IFP; // OK +} + +int test2(double (^S)()) { + double (^I)(int) = (void*) S; + (void*)I = (void *)S; // expected-error {{assignment to cast is illegal, lvalue casts are not supported}} + + void *pv = I; + + pv = S; + + I(1); + + return (void*)I == (void *)S; +} + +int^ x; // expected-error {{block pointer to non-function type is invalid}} +int^^ x1; // expected-error {{block pointer to non-function type is invalid}} expected-error {{block pointer to non-function type is invalid}} + +void test3() { + char *^ y; // expected-error {{block pointer to non-function type is invalid}} +} + + + +enum {NSBIRLazilyAllocated = 0}; + +int test4(int argc) { // rdar://6251437 + ^{ + switch (argc) { + case NSBIRLazilyAllocated: // is an integer constant expression. + default: + break; + } + }(); + return 0; +} + + +void bar(void*); +// rdar://6257721 - reference to static/global is byref by default. +static int test5g; +void test5() { + bar(^{ test5g = 1; }); +} + +// rdar://6405429 - __func__ in a block refers to the containing function name. +const char*test6() { + return ^{ + return __func__; + } (); +} + +// radr://6732116 - block comparisons +void (^test7a)(); +int test7(void (^p)()) { + return test7a == p; +} + + +void test8() { +somelabel: + ^{ goto somelabel; }(); // expected-error {{use of undeclared label 'somelabel'}} +} + +void test9() { + goto somelabel; // expected-error {{use of undeclared label 'somelabel'}} + ^{ somelabel: ; }(); +} + +void test10(int i) { + switch (i) { + case 41: ; + ^{ case 42: ; }(); // expected-error {{'case' statement not in switch statement}} + } +} + +void test11(int i) { + switch (i) { + case 41: ; + ^{ break; }(); // expected-error {{'break' statement not in loop or switch statement}} + } + + for (; i < 100; ++i) + ^{ break; }(); // expected-error {{'break' statement not in loop or switch statement}} +} + +void (^test12f)(void); +void test12() { + test12f = ^test12f; // expected-error {{type name requires a specifier or qualifier}} expected-error {{expected expression}} +} + +// rdar://6808730 +void *test13 = ^{ + int X = 32; + + void *P = ^{ + return X+4; // References outer block's "X", so outer block is constant. + }; +}; + +void test14() { + int X = 32; + static void *P = ^{ // expected-error {{initializer element is not a compile-time constant}} + + void *Q = ^{ + // References test14's "X": outer block is non constant. + return X+4; + }; + }; +} + +enum { LESS }; + +void foo(long (^comp)()) { // expected-note{{passing argument to parameter 'comp' here}} +} + +void (^test15f)(void); +void test15() { + foo(^{ return LESS; }); // expected-error {{incompatible block pointer types passing 'int (^)(void)' to parameter of type 'long (^)()'}} +} + +__block int test16i; // expected-error {{__block attribute not allowed, only allowed on local variables}} + +void test16(__block int i) { // expected-error {{__block attribute not allowed, only allowed on local variables}} + int size = 5; + extern __block double extern_var; // expected-error {{__block attribute not allowed, only allowed on local variables}} + static __block char * pch; // expected-error {{__block attribute not allowed, only allowed on local variables}} + __block int a[size]; // expected-error {{__block attribute not allowed on declaration with a variably modified type}} + __block int (*ap)[size]; // expected-error {{__block attribute not allowed on declaration with a variably modified type}} +} + +void f(); + +void test17() { + void (^bp)(int); + void (*rp)(int); + void (^bp1)(); + void *vp = bp; + + f(1 ? bp : vp); + f(1 ? vp : bp); + f(1 ? bp : bp1); + (void)(bp > rp); // expected-error {{invalid operands}} + (void)(bp > 0); // expected-error {{invalid operands}} + (void)(bp > bp); // expected-error {{invalid operands}} + (void)(bp > vp); // expected-error {{invalid operands}} + f(1 ? bp : rp); // expected-error {{incompatible operand types ('void (^)(int)' and 'void (*)(int)')}} + (void)(bp == 1); // expected-error {{invalid operands to binary expression}} + (void)(bp == 0); + (void)(1 == bp); // expected-error {{invalid operands to binary expression}} + (void)(0 == bp); + (void)(bp < 1); // expected-error {{invalid operands to binary expression}} + (void)(bp < 0); // expected-error {{invalid operands to binary expression}} + (void)(1 < bp); // expected-error {{invalid operands to binary expression}} + (void)(0 < bp); // expected-error {{invalid operands to binary expression}} +} + +void test18() { + void (^const blockA)(void) = ^{ }; + blockA = ^{ }; // expected-error {{read-only variable is not assignable}} +} + +// rdar://7072507 +int test19() { + goto L0; // expected-error {{goto into protected scope}} + + __block int x; // expected-note {{jump bypasses setup of __block variable}} +L0: + x = 0; + ^(){ ++x; }(); + return x; +} + +// radr://7438948 +void test20() { + int n = 7; + int vla[n]; // expected-note {{declared here}} + int (*vm)[n] = 0; // expected-note {{declared here}} + vla[1] = 4341; + ^{ + (void)vla[1]; // expected-error {{cannot refer to declaration with a variably modified type inside block}} + (void)(vm+1); // expected-error {{cannot refer to declaration with a variably modified type inside block}} + }(); +} + +// radr://7438948 +void test21() { + int a[7]; // expected-note {{declared here}} + __block int b[10]; // expected-note {{declared here}} + a[1] = 1; + ^{ + (void)a[1]; // expected-error {{cannot refer to declaration with an array type inside block}} + (void)b[1]; // expected-error {{cannot refer to declaration with an array type inside block}} + }(); +} + +// rdar ://8218839 +const char * (^func)(void) = ^{ return __func__; }; +const char * (^function)(void) = ^{ return __FUNCTION__; }; +const char * (^pretty)(void) = ^{ return __PRETTY_FUNCTION__; }; diff --git a/clang/test/Sema/block-printf-attribute-1.c b/clang/test/Sema/block-printf-attribute-1.c new file mode 100644 index 0000000..dd678a5 --- /dev/null +++ b/clang/test/Sema/block-printf-attribute-1.c @@ -0,0 +1,21 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify -fblocks + +#include <stdarg.h> + +int main() { + void (^b) (int arg, const char * format, ...) __attribute__ ((__format__ (__printf__, 1, 3))) = // expected-error {{format argument not a string type}} + ^ __attribute__ ((__format__ (__printf__, 1, 3))) (int arg, const char * format, ...) {}; // expected-error {{format argument not a string type}} + + void (^z) (int arg, const char * format, ...) __attribute__ ((__format__ (__printf__, 2, 3))) = ^ __attribute__ ((__format__ (__printf__, 2, 3))) (int arg, const char * format, ...) {}; + + z(1, "%s", 1); // expected-warning{{format specifies type 'char *' but the argument has type 'int'}} + z(1, "%s", "HELLO"); // no-warning +} + +void multi_attr(va_list ap, int *x, long *y) { + // Handle block with multiple format attributes. + void (^vprintf_scanf) (const char *, va_list, const char *, ...) __attribute__((__format__(__printf__, 1, 0))) __attribute__((__format__(__scanf__, 3, 4))) = + ^ __attribute__((__format__(__printf__, 1, 0))) __attribute__((__format__(__scanf__, 3, 4))) (const char *str, va_list args, const char *fmt, ...) {}; + + vprintf_scanf("%", ap, "%d"); // expected-warning {{incomplete format specifier}}, expected-warning {{more '%' conversions than data arguments}} +} diff --git a/clang/test/Sema/block-return-1.c b/clang/test/Sema/block-return-1.c new file mode 100644 index 0000000..631a2d4 --- /dev/null +++ b/clang/test/Sema/block-return-1.c @@ -0,0 +1,6 @@ +// RUN: %clang_cc1 -fsyntax-only %s -verify -fblocks + +int j; +void foo() { + ^ (void) { if (j) return 1; }(); // expected-error {{control may reach end of non-void block}} +} diff --git a/clang/test/Sema/block-return-2.c b/clang/test/Sema/block-return-2.c new file mode 100644 index 0000000..d5fbc6f --- /dev/null +++ b/clang/test/Sema/block-return-2.c @@ -0,0 +1,5 @@ +// RUN: %clang_cc1 -fsyntax-only %s -verify -fblocks + +void foo() { + ^ (void) __attribute__((noreturn)) { }(); // expected-error {{block declared 'noreturn' should not return}} +} diff --git a/clang/test/Sema/block-return-3.c b/clang/test/Sema/block-return-3.c new file mode 100644 index 0000000..cd942a7 --- /dev/null +++ b/clang/test/Sema/block-return-3.c @@ -0,0 +1,5 @@ +// RUN: %clang_cc1 -fsyntax-only %s -verify -fblocks + +void foo() { + ^ int (void) { }(); // expected-error {{control reaches end of non-void block}} +} diff --git a/clang/test/Sema/block-return.c b/clang/test/Sema/block-return.c new file mode 100644 index 0000000..6967955 --- /dev/null +++ b/clang/test/Sema/block-return.c @@ -0,0 +1,136 @@ +// RUN: %clang_cc1 -pedantic -fsyntax-only %s -verify -fblocks + +typedef void (^CL)(void); + +CL foo() { + short y; + short (^add1)(void) = ^{ return y+1; }; // expected-error {{incompatible block pointer types initializing 'short (^)(void)' with an expression of type 'int (^)(void)'}} + + CL X = ^{ + if (2) + return; + return 1; // expected-error {{return type 'int' must match previous return type 'void' when block literal has unspecified explicit return type}} + }; + + int (^Y) (void) = ^{ + if (3) + return 1; + else + return; // expected-error {{return type 'void' must match previous return type 'int' when block literal has unspecified explicit return type}} + }; + + char *(^Z)(void) = ^{ + if (3) + return ""; + else + return (char*)0; + }; + + double (^A)(void) = ^ { // expected-error {{incompatible block pointer types initializing 'double (^)(void)' with an expression of type 'float (^)(void)'}} + if (1) + return (float)1.0; + else + if (2) + return (double)2.0; // expected-error {{return type 'double' must match previous return type 'float' when block literal has unspecified explicit return type}} + return 1; // expected-error {{return type 'int' must match previous return type 'float' when block literal has unspecified explicit return type}} + }; + char *(^B)(void) = ^{ + if (3) + return ""; + else + return 2; // expected-error {{return type 'int' must match previous return type 'char *' when block literal has unspecified explicit return type}} + }; + + return ^{ return 1; }; // expected-error {{incompatible block pointer types returning 'int (^)(void)' from a function with result type 'CL' (aka 'void (^)(void)')}} +} + +typedef int (^CL2)(void); + +CL2 foo2() { + return ^{ return 1; }; +} + +typedef unsigned int * uintptr_t; +typedef char Boolean; +typedef int CFBasicHash; + +#define INVOKE_CALLBACK2(P, A, B) (P)(A, B) + +typedef struct { + Boolean (^isEqual)(const CFBasicHash *, uintptr_t stack_value_or_key1, uintptr_t stack_value_or_key2, Boolean is_key); +} CFBasicHashCallbacks; + +int foo3() { + CFBasicHashCallbacks cb; + + Boolean (*value_equal)(uintptr_t, uintptr_t) = 0; + + cb.isEqual = ^(const CFBasicHash *table, uintptr_t stack_value_or_key1, uintptr_t stack_value_or_key2, Boolean is_key) { + return (Boolean)(uintptr_t)INVOKE_CALLBACK2(value_equal, (uintptr_t)stack_value_or_key1, (uintptr_t)stack_value_or_key2); + }; +} + +static int funk(char *s) { + if (^{} == ((void*)0)) + return 1; + else + return 0; +} +void next(); +void foo4() { + int (^xx)(const char *s) = ^(char *s) { return 1; }; // expected-error {{incompatible block pointer types initializing 'int (^)(const char *)' with an expression of type 'int (^)(char *)'}} + int (*yy)(const char *s) = funk; // expected-warning {{incompatible pointer types initializing 'int (*)(const char *)' with an expression of type 'int (char *)'}} + + int (^nested)(char *s) = ^(char *str) { void (^nest)(void) = ^(void) { printf("%s\n", str); }; next(); return 1; }; // expected-warning{{implicitly declaring library function 'printf' with type 'int (const char *, ...)'}} \ + // expected-note{{please include the header <stdio.h> or explicitly provide a declaration for 'printf'}} +} + +typedef void (^bptr)(void); + +bptr foo5(int j) { + __block int i; + if (j) + return ^{ ^{ i=0; }(); }; // expected-error {{returning block that lives on the local stack}} + return ^{ i=0; }; // expected-error {{returning block that lives on the local stack}} + return (^{ i=0; }); // expected-error {{returning block that lives on the local stack}} + return (void*)(^{ i=0; }); // expected-error {{returning block that lives on the local stack}} +} + +int (*funcptr3[5])(long); +int sz8 = sizeof(^int (*[5])(long) {return funcptr3;}); // expected-error {{block cannot return array type}} expected-warning {{incompatible pointer to integer conversion}} +int sz9 = sizeof(^int(*())()[3]{ }); // expected-error {{function cannot return array type}} + +void foo6() { + int (^b)(int) __attribute__((noreturn)); + b = ^ (int i) __attribute__((noreturn)) { return 1; }; // expected-error {{block declared 'noreturn' should not return}} + b(1); + int (^c)(void) __attribute__((noreturn)) = ^ __attribute__((noreturn)) { return 100; }; // expected-error {{block declared 'noreturn' should not return}} +} + + +void foo7() +{ + const int (^BB) (void) = ^{ const int i = 1; return i; }; // OK - initializing 'const int (^)(void)' with an expression of type 'int (^)(void)' + + const int (^CC) (void) = ^const int{ const int i = 1; return i; }; + + + int i; + int (^FF) (void) = ^{ return i; }; // OK + int (^EE) (void) = ^{ return i+1; }; // OK + + __block int j; + int (^JJ) (void) = ^{ return j; }; // OK + int (^KK) (void) = ^{ return j+1; }; // OK + + __block const int k; + const int cint = 100; + + int (^MM) (void) = ^{ return k; }; + int (^NN) (void) = ^{ return cint; }; +} + +// rdar://11069896 +void (^blk)(void) = ^{ + return (void)0; // expected-warning {{void block literal should not return void expression}} +}; diff --git a/clang/test/Sema/block-sentinel-attribute.c b/clang/test/Sema/block-sentinel-attribute.c new file mode 100644 index 0000000..daf0a95 --- /dev/null +++ b/clang/test/Sema/block-sentinel-attribute.c @@ -0,0 +1,25 @@ +// RUN: %clang_cc1 -fblocks -fsyntax-only -verify %s + +void (^e) (int arg, const char * format, ...) __attribute__ ((__sentinel__ (1,1))); + +int main() { + void (^bbad) (int arg, const char * format) __attribute__ ((__sentinel__)) ; // expected-warning {{'sentinel' attribute only supported for variadic blocks}} + bbad = ^void (int arg, const char * format) __attribute__ ((__sentinel__)) {} ; // expected-warning {{'sentinel' attribute only supported for variadic blocks}} + void (^b) (int arg, const char * format, ...) __attribute__ ((__sentinel__)) = // expected-note {{block has been explicitly marked sentinel here}} + ^ __attribute__ ((__sentinel__)) (int arg, const char * format, ...) {}; + void (^z) (int arg, const char * format, ...) __attribute__ ((__sentinel__ (2))) = ^ __attribute__ ((__sentinel__ (2))) (int arg, const char * format, ...) {}; // expected-note {{block has been explicitly marked sentinel here}} + + + void (^y) (int arg, const char * format, ...) __attribute__ ((__sentinel__ (5))) = ^ __attribute__ ((__sentinel__ (5))) (int arg, const char * format, ...) {}; // expected-note {{block has been explicitly marked sentinel here}} + + b(1, "%s", (void*)0); // OK + b(1, "%s", 0); // expected-warning {{missing sentinel in block call}} + z(1, "%s",4 ,1,0); // expected-warning {{missing sentinel in block call}} + z(1, "%s", (void*)0, 1, 0); // OK + + y(1, "%s", 1,2,3,4,5,6,7); // expected-warning {{missing sentinel in block call}} + + y(1, "%s", (void*)0,3,4,5,6,7); // OK + +} + diff --git a/clang/test/Sema/block-storageclass.c b/clang/test/Sema/block-storageclass.c new file mode 100644 index 0000000..9bfbfbd --- /dev/null +++ b/clang/test/Sema/block-storageclass.c @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify -fblocks + +int printf(const char *, ...); +void _Block_byref_release(void*src){} + +int main() { + __block int X = 1234; + __block const char * message = "HELLO"; + + X = X - 1234; + + X += 1; + + printf ("%s(%d)\n", message, X); + X -= 1; + + return X; +} diff --git a/clang/test/Sema/builtin-object-size.c b/clang/test/Sema/builtin-object-size.c new file mode 100644 index 0000000..0abc27b --- /dev/null +++ b/clang/test/Sema/builtin-object-size.c @@ -0,0 +1,28 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -triple x86_64-apple-darwin9 -verify %s + +int a[10]; + +int f0() { + return __builtin_object_size(&a); // expected-error {{too few arguments to function}} +} +int f1() { + return (__builtin_object_size(&a, 0) + + __builtin_object_size(&a, 1) + + __builtin_object_size(&a, 2) + + __builtin_object_size(&a, 3)); +} +int f2() { + return __builtin_object_size(&a, -1); // expected-error {{argument should be a value from 0 to 3}} +} +int f3() { + return __builtin_object_size(&a, 4); // expected-error {{argument should be a value from 0 to 3}} +} + + +// rdar://6252231 - cannot call vsnprintf with va_list on x86_64 +void f4(const char *fmt, ...) { + __builtin_va_list args; + __builtin___vsnprintf_chk (0, 42, 0, 11, fmt, args); +} + diff --git a/clang/test/Sema/builtin-prefetch.c b/clang/test/Sema/builtin-prefetch.c new file mode 100644 index 0000000..c5fa792 --- /dev/null +++ b/clang/test/Sema/builtin-prefetch.c @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +void foo() { + int a; + __builtin_prefetch(&a); + __builtin_prefetch(&a, 1); + __builtin_prefetch(&a, 1, 2); + __builtin_prefetch(&a, 1, 9, 3); // expected-error{{too many arguments to function}} + __builtin_prefetch(&a, "hello", 2); // expected-error{{argument to '__builtin_prefetch' must be a constant integer}} + __builtin_prefetch(&a, a, 2); // expected-error{{argument to '__builtin_prefetch' must be a constant integer}} + __builtin_prefetch(&a, 2); // expected-error{{argument should be a value from 0 to 1}} + __builtin_prefetch(&a, 0, 4); // expected-error{{argument should be a value from 0 to 3}} + __builtin_prefetch(&a, -1, 4); // expected-error{{argument should be a value from 0 to 1}} +} diff --git a/clang/test/Sema/builtin-stackaddress.c b/clang/test/Sema/builtin-stackaddress.c new file mode 100644 index 0000000..5f63bb1 --- /dev/null +++ b/clang/test/Sema/builtin-stackaddress.c @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +void* a(unsigned x) { +return __builtin_return_address(0); +} + +void b(unsigned x) { +return __builtin_return_address(x); // expected-error{{argument to '__builtin_return_address' must be a constant integer}} +} + +void* c(unsigned x) { +return __builtin_frame_address(0); +} + +void d(unsigned x) { +return __builtin_frame_address(x); // expected-error{{argument to '__builtin_frame_address' must be a constant integer}} +} diff --git a/clang/test/Sema/builtin-unary-fp.c b/clang/test/Sema/builtin-unary-fp.c new file mode 100644 index 0000000..57568db --- /dev/null +++ b/clang/test/Sema/builtin-unary-fp.c @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify -pedantic +void check(int); +void a() { + check(__builtin_isfinite(1.0f)); + check(__builtin_isinf(1.0)); + check(__builtin_isinf_sign(1.0L)); + check(__builtin_isnan(1.0f)); + check(__builtin_isnormal(1.0f)); + check(__builtin_isfinite(1)); // expected-error{{requires argument of floating point type}} + check(__builtin_isinf()); // expected-error{{too few arguments}} + check(__builtin_isnan(1,2)); // expected-error{{too many arguments}} + check(__builtin_fpclassify(0, 0, 0, 0, 0, 1.0)); + check(__builtin_fpclassify(0, 0, 0, 0, 0, 1)); // expected-error{{requires argument of floating point type}} + check(__builtin_fpclassify(0, 0, 0, 0, 1)); // expected-error{{too few arguments}} + check(__builtin_fpclassify(0, 0, 0, 0, 0, 1, 0)); // expected-error{{too many arguments}} +} diff --git a/clang/test/Sema/builtin_objc_msgSend.c b/clang/test/Sema/builtin_objc_msgSend.c new file mode 100644 index 0000000..357a5bc --- /dev/null +++ b/clang/test/Sema/builtin_objc_msgSend.c @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify +// rdar://8632525 + +typedef struct objc_class *Class; +typedef struct objc_object { + Class isa; +} *id; + + +typedef struct objc_selector *SEL; +extern id objc_msgSend(id self, SEL op, ...); + diff --git a/clang/test/Sema/builtins-arm.c b/clang/test/Sema/builtins-arm.c new file mode 100644 index 0000000..4077240 --- /dev/null +++ b/clang/test/Sema/builtins-arm.c @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 -triple armv7 -fsyntax-only -verify -DTEST0 %s +// RUN: %clang_cc1 -triple armv7 -fsyntax-only -verify -DTEST1 %s + +#ifdef TEST0 +void __clear_cache(char*, char*); +#endif + +#ifdef TEST1 +void __clear_cache(void*, void*); +#endif + +// va_list on ARM is void*. +void test2() { + __builtin_va_list ptr = "x"; + *ptr = '0'; // expected-error {{incomplete type 'void' is not assignable}} +} diff --git a/clang/test/Sema/builtins-decl.c b/clang/test/Sema/builtins-decl.c new file mode 100644 index 0000000..19bdb84 --- /dev/null +++ b/clang/test/Sema/builtins-decl.c @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify -triple=i686-mingw32 +// RUN: %clang_cc1 %s -fsyntax-only -verify -triple=x86_64-mingw32 + +// mingw-w64's intrin.h has decls below. +// we should accept them. +extern unsigned int __builtin_ia32_crc32qi (unsigned int, unsigned char); +extern unsigned int __builtin_ia32_crc32hi (unsigned int, unsigned short); +extern unsigned int __builtin_ia32_crc32si (unsigned int, unsigned int); diff --git a/clang/test/Sema/builtins.c b/clang/test/Sema/builtins.c new file mode 100644 index 0000000..b8b0367 --- /dev/null +++ b/clang/test/Sema/builtins.c @@ -0,0 +1,164 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify -pedantic -Wno-string-plus-int -triple=i686-apple-darwin9 +// This test needs to set the target because it uses __builtin_ia32_vec_ext_v4si + +int test1(float a, int b) { + return __builtin_isless(a, b); +} +int test2(int a, int b) { + return __builtin_islessequal(a, b); // expected-error {{floating point type}} +} + +int test3(double a, float b) { + return __builtin_isless(a, b); +} +int test4(int* a, double b) { + return __builtin_islessequal(a, b); // expected-error {{floating point type}} +} + +int test5(float a, long double b) { + return __builtin_isless(a, b, b); // expected-error {{too many arguments}} +} +int test6(float a, long double b) { + return __builtin_islessequal(a); // expected-error {{too few arguments}} +} + + +#define CFSTR __builtin___CFStringMakeConstantString +void test7() { + const void *X; + X = CFSTR("\242"); // expected-warning {{input conversion stopped}} + X = CFSTR("\0"); // no-warning + X = CFSTR(242); // expected-error {{CFString literal is not a string constant}} expected-warning {{incompatible integer to pointer conversion}} + X = CFSTR("foo", "bar"); // expected-error {{too many arguments to function call}} +} + + +// atomics. + +void test9(short v) { + unsigned i, old; + + old = __sync_fetch_and_add(); // expected-error {{too few arguments to function call}} + old = __sync_fetch_and_add(&old); // expected-error {{too few arguments to function call}} + old = __sync_fetch_and_add((unsigned*)0, 42i); // expected-warning {{imaginary constants are an extension}} + + // PR7600: Pointers are implicitly casted to integers and back. + void *old_ptr = __sync_val_compare_and_swap((void**)0, 0, 0); + + // Ensure the return type is correct even when implicit casts are stripped + // away. This triggers an assertion while checking the comparison otherwise. + if (__sync_fetch_and_add(&old, 1) == 1) { + } +} + + +// rdar://7236819 +void test10(void) __attribute__((noreturn)); + +void test10(void) { + __asm__("int3"); + __builtin_unreachable(); + + // No warning about falling off the end of a noreturn function. +} + +void test11(int X) { + switch (X) { + case __builtin_eh_return_data_regno(0): // constant foldable. + break; + } + + __builtin_eh_return_data_regno(X); // expected-error {{argument to '__builtin_eh_return_data_regno' must be a constant integer}} +} + +// PR5062 +void test12(void) __attribute__((__noreturn__)); +void test12(void) { + __builtin_trap(); // no warning because trap is noreturn. +} + +void test_unknown_builtin(int a, int b) { + __builtin_isles(a, b); // expected-error{{use of unknown builtin}} \ + // expected-note{{did you mean '__builtin_isless'?}} +} + +int test13() { + __builtin_eh_return(0, 0); // no warning, eh_return never returns. +} + +// <rdar://problem/8228293> +void test14() { + int old; + old = __sync_fetch_and_min((volatile int *)&old, 1); +} + +// <rdar://problem/8336581> +void test15(const char *s) { + __builtin_printf("string is %s\n", s); +} + +// PR7885 +int test16() { + return __builtin_constant_p() + // expected-error{{too few arguments}} + __builtin_constant_p(1, 2); // expected-error {{too many arguments}} +} + +const int test17_n = 0; +const char test17_c[] = {1, 2, 3, 0}; +const char test17_d[] = {1, 2, 3, 4}; +typedef int __attribute__((vector_size(16))) IntVector; +struct Aggregate { int n; char c; }; +enum Enum { EnumValue1, EnumValue2 }; + +typedef __typeof(sizeof(int)) size_t; +size_t strlen(const char *); + +void test17() { +#define ASSERT(...) { int arr[(__VA_ARGS__) ? 1 : -1]; } +#define T(...) ASSERT(__builtin_constant_p(__VA_ARGS__)) +#define F(...) ASSERT(!__builtin_constant_p(__VA_ARGS__)) + + // __builtin_constant_p returns 1 if the argument folds to: + // - an arithmetic constant with value which is known at compile time + T(test17_n); + T(&test17_c[3] - test17_c); + T(3i + 5); // expected-warning {{imaginary constant}} + T(4.2 * 7.6); + T(EnumValue1); + T((enum Enum)(int)EnumValue2); + + // - the address of the first character of a string literal, losslessly cast + // to any type + T("string literal"); + T((double*)"string literal"); + T("string literal" + 0); + T((long)"string literal"); + + // ... and otherwise returns 0. + F("string literal" + 1); + F(&test17_n); + F(test17_c); + F(&test17_c); + F(&test17_d); + F((struct Aggregate){0, 1}); + F((IntVector){0, 1, 2, 3}); + + // Ensure that a technique used in glibc is handled correctly. +#define OPT(...) (__builtin_constant_p(__VA_ARGS__) && strlen(__VA_ARGS__) < 4) + // FIXME: These are incorrectly treated as ICEs because strlen is treated as + // a builtin. + ASSERT(OPT("abc")); + ASSERT(!OPT("abcd")); + // In these cases, the strlen is non-constant, but the __builtin_constant_p + // is 0: the array size is not an ICE but is foldable. + ASSERT(!OPT(test17_c)); // expected-warning {{folded}} + ASSERT(!OPT(&test17_c[0])); // expected-warning {{folded}} + ASSERT(!OPT((char*)test17_c)); // expected-warning {{folded}} + ASSERT(!OPT(test17_d)); // expected-warning {{folded}} + ASSERT(!OPT(&test17_d[0])); // expected-warning {{folded}} + ASSERT(!OPT((char*)test17_d)); // expected-warning {{folded}} + +#undef OPT +#undef T +#undef F +} diff --git a/clang/test/Sema/c11-typedef-redef.c b/clang/test/Sema/c11-typedef-redef.c new file mode 100644 index 0000000..b899f15 --- /dev/null +++ b/clang/test/Sema/c11-typedef-redef.c @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 -std=c11 %s -verify + +typedef int type; +typedef type type; +typedef int type; + +void f(int N) { + typedef int type2; + typedef type type2; + typedef int type2; + + typedef int vla[N]; // expected-note{{previous definition is here}} + typedef int vla[N]; // expected-error{{redefinition of typedef for variably-modified type 'int [N]'}} + + typedef int vla2[N]; + typedef vla2 vla3; // expected-note{{previous definition is here}} + typedef vla2 vla3; // expected-error{{redefinition of typedef for variably-modified type 'vla2' (aka 'int [N]')}} +} diff --git a/clang/test/Sema/c89-2.c b/clang/test/Sema/c89-2.c new file mode 100644 index 0000000..f6f6bd9 --- /dev/null +++ b/clang/test/Sema/c89-2.c @@ -0,0 +1,5 @@ +/* RUN: %clang_cc1 %s -std=c89 -pedantic-errors -verify + */ + +#if 1LL /* expected-error {{long long}} */ +#endif diff --git a/clang/test/Sema/c89.c b/clang/test/Sema/c89.c new file mode 100644 index 0000000..110d7e1 --- /dev/null +++ b/clang/test/Sema/c89.c @@ -0,0 +1,112 @@ +/* RUN: %clang_cc1 %s -std=c89 -pedantic -fsyntax-only -verify -Wimplicit-function-declaration + */ +void test1() { + { + int i; + i = i + 1; + int j; /* expected-warning {{mixing declarations and code}} */ + } + { + __extension__ int i; + i = i + 1; + int j; /* expected-warning {{mixing declarations and code}} */ + } + { + int i; + i = i + 1; + __extension__ int j; /* expected-warning {{mixing declarations and code}} */ + } +} + +long long test2; /* expected-warning {{extension}} */ + + +void test3(int i) { + int A[i]; /* expected-warning {{variable length array}} */ +} + +int test4 = 0LL; /* expected-warning {{long long}} */ + +/* PR1999 */ +void test5(register); + +/* PR2041 */ +int *restrict; +int *__restrict; /* expected-error {{expected identifier}} */ + + +/* Implicit int, always ok */ +test6() { return 0; } + +/* PR2012 */ +test7; /* expected-warning {{declaration specifier missing, defaulting to 'int'}} */ + +void test8(int, x); /* expected-warning {{declaration specifier missing, defaulting to 'int'}} */ + +typedef int sometype; +int a(sometype, y) {return 0;} /* expected-warning {{declaration specifier missing, defaulting to 'int'}} \ + expected-error {{parameter name omitted}}*/ + + + + +void bar (void *); +void f11 (z) /* expected-error {{may not have 'void' type}} */ +void z; +{ bar (&z); } + +typedef void T; +void foo(T); /* typedef for void is allowed */ + +void foo(void) {} + +/* PR2759 */ +void test10 (int x[*]); /* expected-warning {{variable length arrays are a C99 feature}} */ +void test11 (int x[static 4]); /* expected-warning {{static array size is a C99 feature}} */ + +void test12 (int x[const 4]) { /* expected-warning {{qualifier in array size is a C99 feature}} */ + int Y[x[1]]; /* expected-warning {{variable length arrays are a C99 feature}} */ +} + +/* PR4074 */ +struct test13 { + int X[23]; +} test13a(); + +void test13b() { + int a = test13a().X[1]; /* expected-warning {{ISO C90 does not allow subscripting non-lvalue array}} */ + int b = 1[test13a().X]; /* expected-warning {{ISO C90 does not allow subscripting non-lvalue array}} */ +} + +/* Make sure we allow *test14 as a "function designator" */ +int test14() { return (&*test14)(); } + +int test15[5] = { [2] = 1 }; /* expected-warning {{designated initializers are a C99 feature}} */ + +extern int printf(__const char *__restrict __format, ...); + +/* Warn, but don't suggest typo correction. */ +void test16() { + printg("Hello, world!\n"); /* expected-warning {{implicit declaration of function 'printg'}} */ +} + +struct x { int x,y[]; }; /* expected-warning {{Flexible array members are a C99-specific feature}} */ + +/* Duplicated type-qualifiers aren't allowed by C90 */ +const const int c_i; /* expected-warning {{duplicate 'const' declaration specifier}} */ +typedef volatile int vol_int; +volatile vol_int volvol_i; /* expected-warning {{duplicate 'volatile' declaration specifier}} */ +typedef volatile vol_int volvol_int; /* expected-warning {{duplicate 'volatile' declaration specifier}} */ +const int * const c; + +typedef const int CI; + +const CI mine1[5][5]; /* expected-warning {{duplicate 'const' declaration specifier}} */ + +typedef CI array_of_CI[5]; +const array_of_CI mine2; /* expected-warning {{duplicate 'const' declaration specifier}} */ + +typedef CI *array_of_pointer_to_CI[5]; +const array_of_pointer_to_CI mine3; + +void main() {} /* expected-error {{'main' must return 'int'}} */ diff --git a/clang/test/Sema/callingconv.c b/clang/test/Sema/callingconv.c new file mode 100644 index 0000000..25669f0 --- /dev/null +++ b/clang/test/Sema/callingconv.c @@ -0,0 +1,46 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify + +void __attribute__((fastcall)) foo(float *a) { +} + +void __attribute__((stdcall)) bar(float *a) { +} + +void __attribute__((fastcall(1))) baz(float *a) { // expected-error {{attribute takes no arguments}} +} + +void __attribute__((fastcall)) test0() { // expected-error {{function with no prototype cannot use fastcall calling convention}} +} + +void __attribute__((fastcall)) test1(void) { +} + +void __attribute__((fastcall)) test2(int a, ...) { // expected-error {{variadic function cannot use fastcall calling convention}} +} + +void __attribute__((cdecl)) ctest0() {} + +void __attribute__((cdecl(1))) ctest1(float x) {} // expected-error {{attribute takes no arguments}} + +void (__attribute__((fastcall)) *pfoo)(float*) = foo; + +void (__attribute__((stdcall)) *pbar)(float*) = bar; + +void (__attribute__((cdecl)) *ptest1)(void) = test1; // expected-warning {{incompatible pointer types}} + +void (*pctest0)() = ctest0; + +void ctest2() {} +void (__attribute__((cdecl)) *pctest2)() = ctest2; + +typedef void (__attribute__((fastcall)) *Handler) (float *); +Handler H = foo; + +// PR6361 +void ctest3(); +void __attribute__((cdecl)) ctest3() {} + +// PR6408 +typedef __attribute__((stdcall)) void (*PROC)(); +PROC __attribute__((cdecl)) ctest4(const char *x) {} + diff --git a/clang/test/Sema/carbon.c b/clang/test/Sema/carbon.c new file mode 100644 index 0000000..045d72c --- /dev/null +++ b/clang/test/Sema/carbon.c @@ -0,0 +1,5 @@ +// RUN: %clang -fsyntax-only %s -print-stats +#ifdef __APPLE__ +#include <Carbon/Carbon.h> +#endif + diff --git a/clang/test/Sema/cast-incomplete.c b/clang/test/Sema/cast-incomplete.c new file mode 100644 index 0000000..dd10e00 --- /dev/null +++ b/clang/test/Sema/cast-incomplete.c @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 -fsyntax-only %s -verify +// PR5692 + +enum x; // expected-note {{forward declaration}} +extern struct y a; // expected-note {{forward declaration}} +extern union z b; // expected-note 2 {{forward declaration}} + +void foo() { + (enum x)1; // expected-error {{cast to incomplete type}} + (struct y)a; // expected-error {{cast to incomplete type}} + (union z)b; // expected-error {{cast to incomplete type}} + (union z)1; // expected-error {{cast to incomplete type}} +} + diff --git a/clang/test/Sema/cast-to-union.c b/clang/test/Sema/cast-to-union.c new file mode 100644 index 0000000..c32964d --- /dev/null +++ b/clang/test/Sema/cast-to-union.c @@ -0,0 +1,20 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -pedantic %s + +union u { int i; unsigned : 3; }; +void f(union u); + +void test(int x) { + f((union u)x); // expected-warning {{C99 forbids casts to union type}} + f((union u)&x); // expected-error {{cast to union type from type 'int *' not present in union}} + f((union u)2U); // expected-error {{cast to union type from type 'unsigned int' not present in union}} +} + +union u w = (union u)2; // expected-warning {{C99 forbids casts to union type}} +union u ww = (union u)1.0; // expected-error{{cast to union type from type 'double' not present in union}} +union u x = 7; // expected-error{{initializing 'union u' with an expression of incompatible type 'int'}} +int i; +union u zz = (union u)i; // expected-error{{initializer element is not a compile-time constant}} expected-warning {{C99 forbids casts to union type}} + +struct s {int a, b;}; +struct s y = { 1, 5 }; +struct s z = (struct s){ 1, 5 }; diff --git a/clang/test/Sema/cast.c b/clang/test/Sema/cast.c new file mode 100644 index 0000000..71c44b4 --- /dev/null +++ b/clang/test/Sema/cast.c @@ -0,0 +1,159 @@ +// RUN: %clang_cc1 -fsyntax-only %s -verify + +typedef struct { unsigned long bits[(((1) + (64) - 1) / (64))]; } cpumask_t; +cpumask_t x; +void foo() { + (void)x; +} +void bar() { + char* a; + double b; + b = (double)a; // expected-error {{pointer cannot be cast to type}} + a = (char*)b; // expected-error {{cannot be cast to a pointer type}} +} + +long bar1(long *next) { + return (long)(*next)++; +} + +typedef _Bool Bool; +typedef int Int; +typedef long Long; +typedef float Float; +typedef double Double; +typedef _Complex int CInt; +typedef _Complex long CLong; +typedef _Complex float CFloat; +typedef _Complex double CDouble; +typedef void *VoidPtr; +typedef char *CharPtr; + +void testBool(Bool v) { + (void) (Bool) v; + (void) (Int) v; + (void) (Long) v; + (void) (Float) v; + (void) (Double) v; + (void) (CInt) v; + (void) (CLong) v; + (void) (CFloat) v; + (void) (CDouble) v; + (void) (VoidPtr) v; + (void) (CharPtr) v; +} + +void testInt(Int v) { + (void) (Bool) v; + (void) (Int) v; + (void) (Long) v; + (void) (Float) v; + (void) (Double) v; + (void) (CInt) v; + (void) (CLong) v; + (void) (CFloat) v; + (void) (CDouble) v; + (void) (VoidPtr) v; + (void) (CharPtr) v; +} + +void testLong(Long v) { + (void) (Bool) v; + (void) (Int) v; + (void) (Long) v; + (void) (Float) v; + (void) (Double) v; + (void) (CInt) v; + (void) (CLong) v; + (void) (CFloat) v; + (void) (CDouble) v; + (void) (VoidPtr) v; + (void) (CharPtr) v; +} + +void testFloat(Float v) { + (void) (Bool) v; + (void) (Int) v; + (void) (Long) v; + (void) (Float) v; + (void) (Double) v; + (void) (CInt) v; + (void) (CLong) v; + (void) (CFloat) v; + (void) (CDouble) v; +} + +void testDouble(Double v) { + (void) (Bool) v; + (void) (Int) v; + (void) (Long) v; + (void) (Float) v; + (void) (Double) v; + (void) (CInt) v; + (void) (CLong) v; + (void) (CFloat) v; + (void) (CDouble) v; +} + +void testCI(CInt v) { + (void) (Bool) v; + (void) (Int) v; + (void) (Long) v; + (void) (Float) v; + (void) (Double) v; + (void) (CInt) v; + (void) (CLong) v; + (void) (CFloat) v; + (void) (CDouble) v; +} + +void testCLong(CLong v) { + (void) (Bool) v; + (void) (Int) v; + (void) (Long) v; + (void) (Float) v; + (void) (Double) v; + (void) (CInt) v; + (void) (CLong) v; + (void) (CFloat) v; + (void) (CDouble) v; +} + +void testCFloat(CFloat v) { + (void) (Bool) v; + (void) (Int) v; + (void) (Long) v; + (void) (Float) v; + (void) (Double) v; + (void) (CInt) v; + (void) (CLong) v; + (void) (CFloat) v; + (void) (CDouble) v; +} + +void testCDouble(CDouble v) { + (void) (Bool) v; + (void) (Int) v; + (void) (Long) v; + (void) (Float) v; + (void) (Double) v; + (void) (CInt) v; + (void) (CLong) v; + (void) (CFloat) v; + (void) (CDouble) v; +} + +void testVoidPtr(VoidPtr v) { + (void) (Bool) v; + (void) (Int) v; + (void) (Long) v; + (void) (VoidPtr) v; + (void) (CharPtr) v; +} + +void testCharPtr(CharPtr v) { + (void) (Bool) v; + (void) (Int) v; + (void) (Long) v; + (void) (VoidPtr) v; + (void) (CharPtr) v; +} diff --git a/clang/test/Sema/check-increment.c b/clang/test/Sema/check-increment.c new file mode 100644 index 0000000..070ea74 --- /dev/null +++ b/clang/test/Sema/check-increment.c @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +int printf(const char *, ...); +typedef int *pint; +int main() { + int a[5] = {0}; + pint p = a; + p++; + printf("%d\n", *p); +} diff --git a/clang/test/Sema/compare.c b/clang/test/Sema/compare.c new file mode 100644 index 0000000..03aebb3 --- /dev/null +++ b/clang/test/Sema/compare.c @@ -0,0 +1,335 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin -fsyntax-only -pedantic -verify -Wsign-compare %s -Wno-unreachable-code + +int test(char *C) { // nothing here should warn. + return C != ((void*)0); + return C != (void*)0; + return C != 0; + return C != 1; // expected-warning {{comparison between pointer and integer ('char *' and 'int')}} +} + +int ints(long a, unsigned long b) { + enum EnumA {A}; + enum EnumB {B}; + enum EnumC {C = 0x10000}; + return + // (a,b) + (a == (unsigned long) b) + // expected-warning {{comparison of integers of different signs}} + (a == (unsigned int) b) + + (a == (unsigned short) b) + + (a == (unsigned char) b) + + ((long) a == b) + // expected-warning {{comparison of integers of different signs}} + ((int) a == b) + // expected-warning {{comparison of integers of different signs}} + ((short) a == b) + // expected-warning {{comparison of integers of different signs}} + ((signed char) a == b) + // expected-warning {{comparison of integers of different signs}} + ((long) a == (unsigned long) b) + // expected-warning {{comparison of integers of different signs}} + ((int) a == (unsigned int) b) + // expected-warning {{comparison of integers of different signs}} + ((short) a == (unsigned short) b) + + ((signed char) a == (unsigned char) b) + + (a < (unsigned long) b) + // expected-warning {{comparison of integers of different signs}} + (a < (unsigned int) b) + + (a < (unsigned short) b) + + (a < (unsigned char) b) + + ((long) a < b) + // expected-warning {{comparison of integers of different signs}} + ((int) a < b) + // expected-warning {{comparison of integers of different signs}} + ((short) a < b) + // expected-warning {{comparison of integers of different signs}} + ((signed char) a < b) + // expected-warning {{comparison of integers of different signs}} + ((long) a < (unsigned long) b) + // expected-warning {{comparison of integers of different signs}} + ((int) a < (unsigned int) b) + // expected-warning {{comparison of integers of different signs}} + ((short) a < (unsigned short) b) + + ((signed char) a < (unsigned char) b) + + + // (A,b) + (A == (unsigned long) b) + + (A == (unsigned int) b) + + (A == (unsigned short) b) + + (A == (unsigned char) b) + + ((long) A == b) + + ((int) A == b) + + ((short) A == b) + + ((signed char) A == b) + + ((long) A == (unsigned long) b) + + ((int) A == (unsigned int) b) + + ((short) A == (unsigned short) b) + + ((signed char) A == (unsigned char) b) + + (A < (unsigned long) b) + + (A < (unsigned int) b) + + (A < (unsigned short) b) + + (A < (unsigned char) b) + + ((long) A < b) + + ((int) A < b) + + ((short) A < b) + + ((signed char) A < b) + + ((long) A < (unsigned long) b) + + ((int) A < (unsigned int) b) + + ((short) A < (unsigned short) b) + + ((signed char) A < (unsigned char) b) + + + // (a,B) + (a == (unsigned long) B) + + (a == (unsigned int) B) + + (a == (unsigned short) B) + + (a == (unsigned char) B) + + ((long) a == B) + + ((int) a == B) + + ((short) a == B) + + ((signed char) a == B) + + ((long) a == (unsigned long) B) + + ((int) a == (unsigned int) B) + + ((short) a == (unsigned short) B) + + ((signed char) a == (unsigned char) B) + + (a < (unsigned long) B) + // expected-warning {{comparison of integers of different signs}} + (a < (unsigned int) B) + + (a < (unsigned short) B) + + (a < (unsigned char) B) + + ((long) a < B) + + ((int) a < B) + + ((short) a < B) + + ((signed char) a < B) + + ((long) a < (unsigned long) B) + // expected-warning {{comparison of integers of different signs}} + ((int) a < (unsigned int) B) + // expected-warning {{comparison of integers of different signs}} + ((short) a < (unsigned short) B) + + ((signed char) a < (unsigned char) B) + + + // (C,b) + (C == (unsigned long) b) + + (C == (unsigned int) b) + + (C == (unsigned short) b) + + (C == (unsigned char) b) + + ((long) C == b) + + ((int) C == b) + + ((short) C == b) + + ((signed char) C == b) + + ((long) C == (unsigned long) b) + + ((int) C == (unsigned int) b) + + ((short) C == (unsigned short) b) + + ((signed char) C == (unsigned char) b) + + (C < (unsigned long) b) + + (C < (unsigned int) b) + + (C < (unsigned short) b) + + (C < (unsigned char) b) + + ((long) C < b) + + ((int) C < b) + + ((short) C < b) + + ((signed char) C < b) + + ((long) C < (unsigned long) b) + + ((int) C < (unsigned int) b) + + ((short) C < (unsigned short) b) + + ((signed char) C < (unsigned char) b) + + + // (a,C) + (a == (unsigned long) C) + + (a == (unsigned int) C) + + (a == (unsigned short) C) + + (a == (unsigned char) C) + + ((long) a == C) + + ((int) a == C) + + ((short) a == C) + + ((signed char) a == C) + + ((long) a == (unsigned long) C) + + ((int) a == (unsigned int) C) + + ((short) a == (unsigned short) C) + + ((signed char) a == (unsigned char) C) + + (a < (unsigned long) C) + // expected-warning {{comparison of integers of different signs}} + (a < (unsigned int) C) + + (a < (unsigned short) C) + + (a < (unsigned char) C) + + ((long) a < C) + + ((int) a < C) + + ((short) a < C) + + ((signed char) a < C) + + ((long) a < (unsigned long) C) + // expected-warning {{comparison of integers of different signs}} + ((int) a < (unsigned int) C) + // expected-warning {{comparison of integers of different signs}} + ((short) a < (unsigned short) C) + + ((signed char) a < (unsigned char) C) + + + // (0x80000,b) + (0x80000 == (unsigned long) b) + + (0x80000 == (unsigned int) b) + + (0x80000 == (unsigned short) b) + + (0x80000 == (unsigned char) b) + + ((long) 0x80000 == b) + + ((int) 0x80000 == b) + + ((short) 0x80000 == b) + + ((signed char) 0x80000 == b) + + ((long) 0x80000 == (unsigned long) b) + + ((int) 0x80000 == (unsigned int) b) + + ((short) 0x80000 == (unsigned short) b) + + ((signed char) 0x80000 == (unsigned char) b) + + (0x80000 < (unsigned long) b) + + (0x80000 < (unsigned int) b) + + (0x80000 < (unsigned short) b) + + (0x80000 < (unsigned char) b) + + ((long) 0x80000 < b) + + ((int) 0x80000 < b) + + ((short) 0x80000 < b) + + ((signed char) 0x80000 < b) + + ((long) 0x80000 < (unsigned long) b) + + ((int) 0x80000 < (unsigned int) b) + + ((short) 0x80000 < (unsigned short) b) + + ((signed char) 0x80000 < (unsigned char) b) + + + // (a,0x80000) + (a == (unsigned long) 0x80000) + + (a == (unsigned int) 0x80000) + + (a == (unsigned short) 0x80000) + + (a == (unsigned char) 0x80000) + + ((long) a == 0x80000) + + ((int) a == 0x80000) + + ((short) a == 0x80000) + + ((signed char) a == 0x80000) + + ((long) a == (unsigned long) 0x80000) + + ((int) a == (unsigned int) 0x80000) + + ((short) a == (unsigned short) 0x80000) + + ((signed char) a == (unsigned char) 0x80000) + + (a < (unsigned long) 0x80000) + // expected-warning {{comparison of integers of different signs}} + (a < (unsigned int) 0x80000) + + (a < (unsigned short) 0x80000) + + (a < (unsigned char) 0x80000) + + ((long) a < 0x80000) + + ((int) a < 0x80000) + + ((short) a < 0x80000) + + ((signed char) a < 0x80000) + + ((long) a < (unsigned long) 0x80000) + // expected-warning {{comparison of integers of different signs}} + ((int) a < (unsigned int) 0x80000) + // expected-warning {{comparison of integers of different signs}} + ((short) a < (unsigned short) 0x80000) + + ((signed char) a < (unsigned char) 0x80000) + + + // We should be able to avoid warning about this. + (b != (a < 4 ? 1 : 2)) + + + 10 + ; +} + +int equal(char *a, const char *b) { + return a == b; +} + +int arrays(char (*a)[5], char(*b)[10], char(*c)[5]) { + int d = (a == c); + return a == b; // expected-warning {{comparison of distinct pointer types}} +} + +int pointers(int *a) { + return a > 0; // expected-warning {{ordered comparison between pointer and zero ('int *' and 'int') is an extension}} + return a > 42; // expected-warning {{ordered comparison between pointer and integer ('int *' and 'int')}} + return a > (void *)0; // expected-warning {{comparison of distinct pointer types}} +} + +int function_pointers(int (*a)(int), int (*b)(int), void (*c)(int)) { + return a > b; // expected-warning {{ordered comparison of function pointers}} + return function_pointers > function_pointers; // expected-warning {{self-comparison always evaluates to false}} expected-warning{{ordered comparison of function pointers}} + return a > c; // expected-warning {{comparison of distinct pointer types}} + return a == (void *) 0; + return a == (void *) 1; // expected-warning {{equality comparison between function pointer and void pointer}} +} + +int void_pointers(void* foo) { + return foo == (void*) 0; + return foo == (void*) 1; +} + + +int test1(int i) { + enum en { zero }; + return i > zero; +} + +// PR5937 +int test2(int i32) { + struct foo { + unsigned int u8 : 8; + unsigned long long u31 : 31; + unsigned long long u32 : 32; + unsigned long long u63 : 63; + unsigned long long u64 : 64; + } *x; + + if (x->u8 == i32) { // comparison in int32, exact + return 0; + } else if (x->u31 == i32) { // comparison in int32, exact + return 1; + } else if (x->u32 == i32) { // expected-warning {{comparison of integers of different signs}} + return 2; + } else if (x->u63 == i32) { // comparison in uint64, exact because == + return 3; + } else if (x->u64 == i32) { // expected-warning {{comparison of integers of different signs}} + return 4; + } else { + return 5; + } +} + +// PR5887 +void test3() { + unsigned short x, y; + unsigned int z; + if ((x > y ? x : y) > z) + (void) 0; +} + +// PR5961 +extern char *ptr4; +void test4() { + long value; + if (value < (unsigned long) &ptr4) // expected-warning {{comparison of integers of different signs}} + return; +} + +// PR4807 +int test5(unsigned int x) { + return (x < 0) // expected-warning {{comparison of unsigned expression < 0 is always false}} + && (0 > x) // expected-warning {{comparison of 0 > unsigned expression is always false}} + && (x >= 0) // expected-warning {{comparison of unsigned expression >= 0 is always true}} + && (0 <= x); // expected-warning {{comparison of 0 <= unsigned expression is always true}} +} + +int test6(unsigned i, unsigned power) { + unsigned x = (i < (1 << power) ? i : 0); + return x != 3 ? 1 << power : i; +} + +// <rdar://problem/8414119> enum >= (enum)0 comparison should not generate any warnings +enum rdar8414119_Vals { X, Y, Z }; +#define ZERO 0 +#define CHECK(x) (x >= X) +void rdar8414119_foo(enum rdar8414119_Vals v) { + if (CHECK(v)) // no-warning + return; + if (v >= X) // no-warning + return; +} +int rdar8414119_bar(unsigned x) { + return x >= ZERO; // no-warning +} +#undef ZERO +#undef CHECK + +int rdar8511238() { + enum A { A_foo, A_bar }; + enum A a; + if (a < 0) // expected-warning {{comparison of unsigned enum expression < 0 is always false}} + return 0; + return 20; +} + +// PR10336 +int test9(int sv, unsigned uv, long slv) { + return sv == (uv ^= slv); // expected-warning {{comparison of integers of different signs: 'int' and 'unsigned int'}} +} + +void test10(void) { + int si; + unsigned int ui; + long sl; + + _Bool b; + b = (si == (ui = sl)); // expected-warning {{comparison of integers of different signs: 'int' and 'unsigned int'}} + b = (si == (ui = sl&15)); +} + +// PR11572 +struct test11S { unsigned x : 30; }; +int test11(unsigned y, struct test11S *p) { + return y > (p->x >> 24); // no-warning +} diff --git a/clang/test/Sema/complex-imag.c b/clang/test/Sema/complex-imag.c new file mode 100644 index 0000000..1c6fb15 --- /dev/null +++ b/clang/test/Sema/complex-imag.c @@ -0,0 +1,29 @@ +// RUN: %clang_cc1 -verify %s + +void f1() { + int a = 1; + int b = __imag a; + int *c = &__real a; + int *d = &__imag a; // expected-error {{must be an lvalue}} +} + +void f2() { + _Complex int a = 1; + int b = __imag a; + int *c = &__real a; + int *d = &__imag a; +} + +void f3() { + double a = 1; + double b = __imag a; + double *c = &__real a; + double *d = &__imag a; // expected-error {{must be an lvalue}} +} + +void f4() { + _Complex double a = 1; + double b = __imag a; + double *c = &__real a; + double *d = &__imag a; +} diff --git a/clang/test/Sema/complex-init-list.c b/clang/test/Sema/complex-init-list.c new file mode 100644 index 0000000..bfc6899 --- /dev/null +++ b/clang/test/Sema/complex-init-list.c @@ -0,0 +1,48 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only -pedantic + +// This file tests the clang extension which allows initializing the components +// of a complex number individually using an initialization list. Basically, +// if you have an explicit init list for a complex number that contains two +// initializers, this extension kicks in to turn it into component-wise +// initialization. +// +// This extension is useful because there isn't any way to accurately build +// a complex number at the moment besides setting the components with +// __real__ and __imag__, which is inconvenient and not usable for constants. +// (Of course, there are other extensions we could implement that would +// allow this, like some sort of __builtin_build_complex.) +// +// FIXME: It would be a good idea to have a warnings for implicit +// real->complex and complex->real conversions; as-is, it's way too easy +// to get implicit conversions when they are not intended. + +// Basic testcase +_Complex float valid1 = { 1.0f, 2.0f }; // expected-warning {{specifying real and imaginary components is an extension}} + + +// Struct for nesting tests +struct teststruct { _Complex float x; }; + + +// Random other valid stuff +_Complex int valid2 = { 1, 2 }; // expected-warning {{complex integer}} expected-warning {{specifying real and imaginary components is an extension}} +struct teststruct valid3 = { { 1.0f, 2.0f} }; // expected-warning {{specifying real and imaginary components is an extension}} +_Complex float valid4[2] = { {1.0f, 1.0f}, {1.0f, 1.0f} }; // expected-warning 2 {{specifying real and imaginary components is an extension}} +// FIXME: We need some sort of warning for valid5 +_Complex float valid5 = {1.0f, 1.0fi}; // expected-warning {{imaginary constants}} expected-warning {{specifying real and imaginary components is an extension}} + + +// Random invalid stuff +struct teststruct invalid1 = { 1, 2 }; // expected-warning {{excess elements}} +_Complex float invalid2 = { 1, 2, 3 }; // expected-warning {{excess elements}} +_Complex float invalid3 = {}; // expected-error {{scalar initializer cannot be empty}} expected-warning {{GNU empty initializer}} + + +// Check incomplete array sizing +_Complex float sizetest1[] = { {1.0f, 1.0f}, {1.0f, 1.0f} }; // expected-warning 2 {{specifying real and imaginary components is an extension}} +_Complex float sizecheck1[(sizeof(sizetest1) == sizeof(*sizetest1)*2) ? 1 : -1]; +_Complex float sizetest2[] = { 1.0f, 1.0f, {1.0f, 1.0f} }; // expected-warning {{specifying real and imaginary components is an extension}} +_Complex float sizecheck2[(sizeof(sizetest2) == sizeof(*sizetest2)*3) ? 1 : -1]; + +// Constant-folding with init list. +_Complex float x = 2 + (_Complex float) { 1, 2 }; // expected-warning {{specifying real and imaginary components is an extension}} diff --git a/clang/test/Sema/complex-int.c b/clang/test/Sema/complex-int.c new file mode 100644 index 0000000..32249b3 --- /dev/null +++ b/clang/test/Sema/complex-int.c @@ -0,0 +1,67 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only + +void a() { +__complex__ int arr; +__complex__ short brr; +__complex__ unsigned xx; +__complex__ signed yy; +__complex__ int result; +int ii; +int aa = 1 + 1.0iF; + +result = arr*ii; +result = ii*brr; + +result = arr*brr; +result = xx*yy; + +switch (arr) { // expected-error{{statement requires expression of integer type ('_Complex int' invalid)}} + case brr: ; // expected-error{{expression is not an integer constant expression}} + case xx: ; // expected-error{{expression is not an integer constant expression}} +} +} + +void Tester() { +__complex short a1; +__complex int a2; +__complex float a3; +__complex double a4; +short a5; +int a6; +float a7; +double a8; +#define TestPair(m,n) int x##m##n = a##m+a##n; +#define TestPairs(m) TestPair(m,1) TestPair(m,2) \ + TestPair(m,3) TestPair(m,4) \ + TestPair(m,5) TestPair(m,6) \ + TestPair(m,7) TestPair(m,8) +TestPairs(1); TestPairs(2); +TestPairs(3); TestPairs(4); +TestPairs(5); TestPairs(6); +TestPairs(7); TestPairs(8); +} + +// rdar://6097730 +void test3(_Complex int *x) { + *x = ~*x; +} + +void test4(_Complex float *x) { + *x = ~*x; +} + +void test5(_Complex int *x) { + (*x)++; +} + +int i1[(2+3i)*(5+7i) == 29i-11 ? 1 : -1]; +int i2[(29i-11)/(5+7i) == 2+3i ? 1 : -1]; +int i3[-(2+3i) == +(-3i-2) ? 1 : -1]; +int i4[~(2+3i) == 2-3i ? 1 : -1]; +int i5[(3i == -(-3i) ? ((void)3, 1i - 1) : 0) == 1i - 1 ? 1 : -1]; + +int f1[(2.0+3.0i)*(5.0+7.0i) == 29.0i-11.0 ? 1 : -1]; +int f2[(29.0i-11.0)/(5.0+7.0i) == 2.0+3.0i ? 1 : -1]; +int f3[-(2.0+3.0i) == +(-3.0i-2.0) ? 1 : -1]; +int f4[~(2.0+3.0i) == 2.0-3.0i ? 1 : -1]; +int f5[(3.0i == -(-3.0i) ? ((void)3.0, __extension__ (1.0i - 1.0)) : 0) == 1.0i - 1.0 ? 1 : -1]; diff --git a/clang/test/Sema/complex-promotion.c b/clang/test/Sema/complex-promotion.c new file mode 100644 index 0000000..23c3b68 --- /dev/null +++ b/clang/test/Sema/complex-promotion.c @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only + +float a; + +int b[__builtin_classify_type(a + 1i) == 9 ? 1 : -1]; +int c[__builtin_classify_type(1i + a) == 9 ? 1 : -1]; + +double d; +__typeof__ (d + 1i) e; + +int f[sizeof(e) == 2 * sizeof(double) ? 1 : -1]; + +int g; +int h[__builtin_classify_type(g + 1.0i) == 9 ? 1 : -1]; +int i[__builtin_classify_type(1.0i + a) == 9 ? 1 : -1]; diff --git a/clang/test/Sema/compound-literal.c b/clang/test/Sema/compound-literal.c new file mode 100644 index 0000000..beec6ca --- /dev/null +++ b/clang/test/Sema/compound-literal.c @@ -0,0 +1,37 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -pedantic %s + +struct foo { int a, b; }; + +static struct foo t = (struct foo){0,0}; +static struct foo t1 = __builtin_choose_expr(0, (struct foo){0,0}, (struct foo){0,0}); +static struct foo t2 = {0,0}; +static struct foo t3 = t2; // -expected-error {{initializer element is not a compile-time constant}} +static int *p = (int []){2,4}; +static int x = (int){1}; + +static int *p2 = (int []){2,x}; // -expected-error {{initializer element is not a compile-time constant}} +static long *p3 = (long []){2,"x"}; // -expected-warning {{incompatible pointer to integer conversion initializing 'long' with an expression of type 'char [2]'}} + +typedef struct { } cache_t; // -expected-warning{{empty struct is a GNU extension}} +static cache_t clo_I1_cache = ((cache_t) { } ); // -expected-warning{{use of GNU empty initializer extension}} + +typedef struct Test {int a;int b;} Test; +static Test* ll = &(Test) {0,0}; + +extern void fooFunc(struct foo *pfoo); + +int main(int argc, char **argv) { + int *l = (int []){x, *p, *p2}; + fooFunc(&(struct foo){ 1, 2 }); +} + +struct Incomplete; // expected-note{{forward declaration of 'struct Incomplete'}} +struct Incomplete* I1 = &(struct Incomplete){1, 2, 3}; // -expected-error {{variable has incomplete type}} +void IncompleteFunc(unsigned x) { + struct Incomplete* I2 = (struct foo[x]){1, 2, 3}; // -expected-error {{variable-sized object may not be initialized}} + (void){1,2,3}; // -expected-error {{variable has incomplete type}} + (void(void)) { 0 }; // -expected-error{{illegal initializer type 'void (void)'}} +} + +// PR6080 +int array[(sizeof(int[3]) == sizeof( (int[]) {0,1,2} )) ? 1 : -1]; diff --git a/clang/test/Sema/conditional-expr.c b/clang/test/Sema/conditional-expr.c new file mode 100644 index 0000000..184ac4a --- /dev/null +++ b/clang/test/Sema/conditional-expr.c @@ -0,0 +1,112 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -Wsign-conversion %s +void foo() { + *(0 ? (double *)0 : (void *)0) = 0; + // FIXME: GCC doesn't consider the the following two statements to be errors. + *(0 ? (double *)0 : (void *)(int *)0) = 0; // expected-error {{incomplete type 'void' is not assignable}} + *(0 ? (double *)0 : (void *)(double *)0) = 0; // expected-error {{incomplete type 'void' is not assignable}} + *(0 ? (double *)0 : (int *)(void *)0) = 0; // expected-error {{incomplete type 'void' is not assignable}} expected-warning {{pointer type mismatch ('double *' and 'int *')}} + *(0 ? (double *)0 : (double *)(void *)0) = 0; + *((void *) 0) = 0; // expected-error {{incomplete type 'void' is not assignable}} + double *dp; + int *ip; + void *vp; + + dp = vp; + vp = dp; + ip = dp; // expected-warning {{incompatible pointer types assigning to 'int *' from 'double *'}} + dp = ip; // expected-warning {{incompatible pointer types assigning to 'double *' from 'int *'}} + dp = 0 ? (double *)0 : (void *)0; + vp = 0 ? (double *)0 : (void *)0; + ip = 0 ? (double *)0 : (void *)0; // expected-warning {{incompatible pointer types assigning to 'int *' from 'double *'}} + + const int *cip; + vp = (0 ? vp : cip); // expected-warning {{discards qualifiers}} + vp = (0 ? cip : vp); // expected-warning {{discards qualifiers}} + + int i = 2; + int (*pf)[2]; + int (*pv)[i]; + pf = (i ? pf : pv); + + enum {xxx,yyy,zzz} e, *ee; + short x; + ee = ee ? &x : ee ? &i : &e; // expected-warning {{pointer type mismatch}} + + typedef void *asdf; + *(0 ? (asdf) 0 : &x) = 10; + + unsigned long test0 = 5; + test0 = test0 ? (long) test0 : test0; // expected-warning {{operand of ? changes signedness: 'long' to 'unsigned long'}} + test0 = test0 ? (int) test0 : test0; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}} + test0 = test0 ? (short) test0 : test0; // expected-warning {{operand of ? changes signedness: 'short' to 'unsigned long'}} + test0 = test0 ? test0 : (long) test0; // expected-warning {{operand of ? changes signedness: 'long' to 'unsigned long'}} + test0 = test0 ? test0 : (int) test0; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}} + test0 = test0 ? test0 : (short) test0; // expected-warning {{operand of ? changes signedness: 'short' to 'unsigned long'}} + test0 = test0 ? test0 : (long) 10; + test0 = test0 ? test0 : (int) 10; + test0 = test0 ? test0 : (short) 10; + test0 = test0 ? (long) 10 : test0; + test0 = test0 ? (int) 10 : test0; + test0 = test0 ? (short) 10 : test0; + + int test1; + enum Enum { EVal }; + test0 = test0 ? EVal : test0; + test1 = test0 ? EVal : (int) test0; + test0 = test0 ? + (unsigned) EVal + : (int) test0; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}} + + test0 = test0 ? EVal : test1; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}} + test0 = test0 ? test1 : EVal; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}} + + const int *const_int; + int *nonconst_int; + *(test0 ? const_int : nonconst_int) = 42; // expected-error {{read-only variable is not assignable}} + *(test0 ? nonconst_int : const_int) = 42; // expected-error {{read-only variable is not assignable}} + + // The composite type here should be "int (*)[12]", fine for the sizeof + int (*incomplete)[]; + int (*complete)[12]; + sizeof(*(test0 ? incomplete : complete)); // expected-warning {{expression result unused}} + sizeof(*(test0 ? complete : incomplete)); // expected-warning {{expression result unused}} + + int __attribute__((address_space(2))) *adr2; + int __attribute__((address_space(3))) *adr3; + test0 ? adr2 : adr3; // expected-warning {{pointer type mismatch}} expected-warning {{expression result unused}} + + // Make sure address-space mask ends up in the result type + (test0 ? (test0 ? adr2 : adr2) : nonconst_int); // expected-warning {{pointer type mismatch}} expected-warning {{expression result unused}} +} + +int Postgresql() { + char x; + return ((((&x) != ((void *) 0)) ? (*(&x) = ((char) 1)) : (void) ((void *) 0)), (unsigned long) ((void *) 0)); // expected-warning {{C99 forbids conditional expressions with only one void side}} +} + +#define nil ((void*) 0) + +extern int f1(void); + +int f0(int a) { + // GCC considers this a warning. + return a ? f1() : nil; // expected-warning {{pointer/integer type mismatch in conditional expression ('int' and 'void *')}} expected-warning {{incompatible pointer to integer conversion returning 'void *' from a function with result type 'int'}} +} + +int f2(int x) { + // We can suppress this because the immediate context wants an int. + return (x != 0) ? 0U : x; +} + +#define NULL (void*)0 + +void PR9236() { + struct A {int i;} A1; + (void)(1 ? A1 : NULL); // expected-error{{non-pointer operand type 'struct A' incompatible with NULL}} + (void)(1 ? NULL : A1); // expected-error{{non-pointer operand type 'struct A' incompatible with NULL}} + (void)(1 ? 0 : A1); // expected-error{{incompatible operand types}} + (void)(1 ? (void*)0 : A1); // expected-error{{incompatible operand types}} + (void)(1 ? A1: (void*)0); // expected-error{{incompatible operand types}} + (void)(1 ? A1 : (NULL)); // expected-error{{non-pointer operand type 'struct A' incompatible with NULL}} +} + diff --git a/clang/test/Sema/conditional.c b/clang/test/Sema/conditional.c new file mode 100644 index 0000000..3d7bcca --- /dev/null +++ b/clang/test/Sema/conditional.c @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify + +const char* test1 = 1 ? "i" : 1 == 1 ? "v" : "r"; + +void _efree(void *ptr); +void free(void *ptr); + +int _php_stream_free1() { + return (1 ? free(0) : _efree(0)); // expected-error {{returning 'void' from a function with incompatible result type 'int'}} +} + +int _php_stream_free2() { + return (1 ? _efree(0) : free(0)); // expected-error {{returning 'void' from a function with incompatible result type 'int'}} +} diff --git a/clang/test/Sema/const-eval-64.c b/clang/test/Sema/const-eval-64.c new file mode 100644 index 0000000..5727a93 --- /dev/null +++ b/clang/test/Sema/const-eval-64.c @@ -0,0 +1,7 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-linux %s + +#define EVAL_EXPR(testno, expr) int test##testno = sizeof(struct{char qq[expr];}); + +// <rdar://problem/10962435> +EVAL_EXPR(1, ((char*)-1LL) + 1 == 0 ? 1 : -1) +EVAL_EXPR(2, ((char*)-1LL) + 1 < (char*) -1 ? 1 : -1) diff --git a/clang/test/Sema/const-eval.c b/clang/test/Sema/const-eval.c new file mode 100644 index 0000000..bc8b227 --- /dev/null +++ b/clang/test/Sema/const-eval.c @@ -0,0 +1,133 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -triple i686-linux %s + +#define EVAL_EXPR(testno, expr) int test##testno = sizeof(struct{char qq[expr];}); +int x; +EVAL_EXPR(1, (_Bool)&x) +EVAL_EXPR(2, (int)(1.0+(double)4)) +EVAL_EXPR(3, (int)(1.0+(float)4.0)) +EVAL_EXPR(4, (_Bool)(1 ? (void*)&x : 0)) +EVAL_EXPR(5, (_Bool)(int[]){0}) +struct y {int x,y;}; +EVAL_EXPR(6, (int)(1+(struct y*)0)) +EVAL_EXPR(7, (int)&((struct y*)0)->y) +EVAL_EXPR(8, (_Bool)"asdf") +EVAL_EXPR(9, !!&x) +EVAL_EXPR(10, ((void)1, 12)) +void g0(void); +EVAL_EXPR(11, (g0(), 12)) // expected-error {{must have a constant size}} +EVAL_EXPR(12, 1.0&&2.0) +EVAL_EXPR(13, x || 3.0) // expected-error {{must have a constant size}} + +unsigned int l_19 = 1; +EVAL_EXPR(14, (1 ^ l_19) && 1); // expected-error {{fields must have a constant size}} + +void f() +{ + int a; + EVAL_EXPR(15, (_Bool)&a); +} + +// FIXME: Turn into EVAL_EXPR test once we have more folding. +_Complex float g16 = (1.0f + 1.0fi); + +// ?: in constant expressions. +int g17[(3?:1) - 2]; + +EVAL_EXPR(18, ((int)((void*)10 + 10)) == 20 ? 1 : -1); + +struct s { + int a[(int)-1.0f]; // expected-error {{'a' declared as an array with a negative size}} +}; + +EVAL_EXPR(19, ((int)&*(char*)10 == 10 ? 1 : -1)); + +EVAL_EXPR(20, __builtin_constant_p(*((int*) 10))); + +EVAL_EXPR(21, (__imag__ 2i) == 2 ? 1 : -1); + +EVAL_EXPR(22, (__real__ (2i+3)) == 3 ? 1 : -1); + +int g23[(int)(1.0 / 1.0)] = { 1 }; +int g24[(int)(1.0 / 1.0)] = { 1 , 2 }; // expected-warning {{excess elements in array initializer}} +int g25[(int)(1.0 + 1.0)], g26 = sizeof(g25); + +EVAL_EXPR(26, (_Complex double)0 ? -1 : 1) +EVAL_EXPR(27, (_Complex int)0 ? -1 : 1) +EVAL_EXPR(28, (_Complex double)1 ? 1 : -1) +EVAL_EXPR(29, (_Complex int)1 ? 1 : -1) + + +// PR4027 + rdar://6808859 +struct a { int x, y; }; +static struct a V2 = (struct a)(struct a){ 1, 2}; +static const struct a V1 = (struct a){ 1, 2}; + +EVAL_EXPR(30, (int)(_Complex float)((1<<30)-1) == (1<<30) ? 1 : -1) +EVAL_EXPR(31, (int*)0 == (int*)0 ? 1 : -1) +EVAL_EXPR(32, (int*)0 != (int*)0 ? -1 : 1) +EVAL_EXPR(33, (void*)0 - (void*)0 == 0 ? 1 : -1) +void foo(void) {} +EVAL_EXPR(34, (foo == (void *)0) ? -1 : 1) + +// No PR. Mismatched bitwidths lead to a crash on second evaluation. +const _Bool constbool = 0; +EVAL_EXPR(35, constbool) +EVAL_EXPR(36, constbool) + +EVAL_EXPR(37, (1,2.0) == 2.0 ? 1 : -1) +EVAL_EXPR(38, __builtin_expect(1,1) == 1 ? 1 : -1) + +// PR7884 +EVAL_EXPR(39, __real__(1.f) == 1 ? 1 : -1) +EVAL_EXPR(40, __imag__(1.f) == 0 ? 1 : -1) + +// From gcc testsuite +EVAL_EXPR(41, (int)(1+(_Complex unsigned)2)) + +// rdar://8875946 +void rdar8875946() { + double _Complex P; + float _Complex P2 = 3.3f + P; +} + +double d = (d = 0.0); // expected-error {{not a compile-time constant}} +double d2 = ++d; // expected-error {{not a compile-time constant}} + +int n = 2; +int intLvalue[*(int*)((long)&n ?: 1)] = { 1, 2 }; // expected-error {{variable length array}} + +union u { int a; char b[4]; }; +char c = ((union u)(123456)).b[0]; // expected-error {{not a compile-time constant}} + +extern const int weak_int __attribute__((weak)); +const int weak_int = 42; +int weak_int_test = weak_int; // expected-error {{not a compile-time constant}} + +int literalVsNull1 = "foo" == 0; +int literalVsNull2 = 0 == "foo"; + +// PR11385. +int castViaInt[*(int*)(unsigned long)"test"]; // expected-error {{variable length array}} + +// PR11391. +struct PR11391 { _Complex float f; } pr11391; +EVAL_EXPR(42, __builtin_constant_p(pr11391.f = 1)) + +// PR12043 +float varfloat; +const float constfloat = 0; +EVAL_EXPR(43, varfloat && constfloat) // expected-error {{must have a constant size}} + +// <rdar://problem/11205586> +// (Make sure we continue to reject this.) +EVAL_EXPR(44, "x"[0]); // expected-error {{variable length array}} + +// <rdar://problem/10962435> +EVAL_EXPR(45, ((char*)-1) + 1 == 0 ? 1 : -1) +EVAL_EXPR(46, ((char*)-1) + 1 < (char*) -1 ? 1 : -1) +EVAL_EXPR(47, &x < &x + 1 ? 1 : -1) +EVAL_EXPR(48, &x != &x - 1 ? 1 : -1) +EVAL_EXPR(49, &x < &x - 100 ? 1 : -1) // expected-error {{must have a constant size}} + +extern struct Test50S Test50; +EVAL_EXPR(50, &Test50 < (struct Test50S*)((unsigned)&Test50 + 10)) // expected-error {{must have a constant size}} diff --git a/clang/test/Sema/const-ptr-int-ptr-cast.c b/clang/test/Sema/const-ptr-int-ptr-cast.c new file mode 100644 index 0000000..8beaf9d --- /dev/null +++ b/clang/test/Sema/const-ptr-int-ptr-cast.c @@ -0,0 +1,5 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -ffreestanding %s + +#include <stdint.h> + +char *a = (void*)(uintptr_t)(void*)&a; diff --git a/clang/test/Sema/constant-builtins-2.c b/clang/test/Sema/constant-builtins-2.c new file mode 100644 index 0000000..68b46bf --- /dev/null +++ b/clang/test/Sema/constant-builtins-2.c @@ -0,0 +1,56 @@ +// RUN: %clang_cc1 -fsyntax-only %s + +// Math stuff + +double g0 = __builtin_huge_val(); +float g1 = __builtin_huge_valf(); +long double g2 = __builtin_huge_vall(); + +double g3 = __builtin_inf(); +float g4 = __builtin_inff(); +long double g5 = __builtin_infl(); + +double g6 = __builtin_nan(""); +float g7 = __builtin_nanf(""); +long double g8 = __builtin_nanl(""); + +// GCC constant folds these too (via native strtol): +//double g6_1 = __builtin_nan("1"); +//float g7_1 = __builtin_nanf("1"); +//long double g8_1 = __builtin_nanl("1"); + +// APFloat doesn't have signalling NaN functions. +//double g9 = __builtin_nans(""); +//float g10 = __builtin_nansf(""); +//long double g11 = __builtin_nansl(""); + +//int g12 = __builtin_abs(-12); + +double g13 = __builtin_fabs(-12.); +double g13_0 = __builtin_fabs(-0.); +double g13_1 = __builtin_fabs(-__builtin_inf()); +float g14 = __builtin_fabsf(-12.f); +// GCC doesn't eat this one. +//long double g15 = __builtin_fabsfl(-12.0L); + +float g16 = __builtin_copysign(1.0, -1.0); +double g17 = __builtin_copysignf(1.0f, -1.0f); +long double g18 = __builtin_copysignl(1.0L, -1.0L); + +//double g19 = __builtin_powi(2.0, 4); +//float g20 = __builtin_powif(2.0f, 4); +//long double g21 = __builtin_powil(2.0L, 4); + +// GCC misc stuff + +extern int f(); + +int h0 = __builtin_types_compatible_p(int, float); +//int h1 = __builtin_choose_expr(1, 10, f()); +//int h2 = __builtin_expect(0, 0); +extern long int bi0; +extern __typeof__(__builtin_expect(0, 0)) bi0; + +// Strings +int array1[__builtin_strlen("ab\0cd")]; +int array2[(sizeof(array1)/sizeof(int)) == 2? 1 : -1]; diff --git a/clang/test/Sema/constant-builtins.c b/clang/test/Sema/constant-builtins.c new file mode 100644 index 0000000..5d67fc7 --- /dev/null +++ b/clang/test/Sema/constant-builtins.c @@ -0,0 +1,24 @@ +// RUN: %clang_cc1 -fsyntax-only %s -verify -pedantic + +// Math stuff + +float g0 = __builtin_huge_val(); +double g1 = __builtin_huge_valf(); +long double g2 = __builtin_huge_vall(); +float g3 = __builtin_inf(); +double g4 = __builtin_inff(); +long double g5 = __builtin_infl(); + +// GCC misc stuff + +extern int f(); + +int h0 = __builtin_types_compatible_p(int,float); +//int h1 = __builtin_choose_expr(1, 10, f()); +//int h2 = __builtin_expect(0, 0); + +short somefunc(); + +short t = __builtin_constant_p(5353) ? 42 : somefunc(); + + diff --git a/clang/test/Sema/constant-conversion.c b/clang/test/Sema/constant-conversion.c new file mode 100644 index 0000000..1376333 --- /dev/null +++ b/clang/test/Sema/constant-conversion.c @@ -0,0 +1,82 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-apple-darwin %s + +// This file tests -Wconstant-conversion, a subcategory of -Wconversion +// which is on by default. + +// rdar://problem/6792488 +void test_6792488(void) { + int x = 0x3ff0000000000000U; // expected-warning {{implicit conversion from 'unsigned long' to 'int' changes value from 4607182418800017408 to 0}} +} + +void test_7809123(void) { + struct { int i5 : 5; } a; + + a.i5 = 36; // expected-warning {{implicit truncation from 'int' to bitfield changes value from 36 to 4}} +} + +void test() { + struct { int bit : 1; } a; + a.bit = 1; // shouldn't warn +} + +enum Test2 { K_zero, K_one }; +enum Test2 test2(enum Test2 *t) { + *t = 20; + return 10; // shouldn't warn +} + +void test3() { + struct A { + unsigned int foo : 2; + int bar : 2; + }; + + struct A a = { 0, 10 }; // expected-warning {{implicit truncation from 'int' to bitfield changes value from 10 to -2}} + struct A b[] = { 0, 10, 0, 0 }; // expected-warning {{implicit truncation from 'int' to bitfield changes value from 10 to -2}} + struct A c[] = {{10, 0}}; // expected-warning {{implicit truncation from 'int' to bitfield changes value from 10 to 2}} + struct A d = (struct A) { 10, 0 }; // expected-warning {{implicit truncation from 'int' to bitfield changes value from 10 to 2}} + struct A e = { .foo = 10 }; // expected-warning {{implicit truncation from 'int' to bitfield changes value from 10 to 2}} +} + +void test4() { + struct A { + char c : 2; + } a; + + a.c = 0x101; // expected-warning {{implicit truncation from 'int' to bitfield changes value from 257 to 1}} +} + +void test5() { + struct A { + _Bool b : 1; + } a; + + // Don't warn about this implicit conversion to bool, or at least + // don't warn about it just because it's a bitfield. + a.b = 100; +} + +void test6() { + // Test that unreachable code doesn't trigger the truncation warning. + unsigned char x = 0 ? 65535 : 1; // no-warning + unsigned char y = 1 ? 65535 : 1; // expected-warning {{changes value}} +} + +void test7() { + struct { + unsigned int twoBits1:2; + unsigned int twoBits2:2; + unsigned int reserved:28; + } f; + + f.twoBits1 = ~1; // expected-warning {{implicit truncation from 'int' to bitfield changes value from -2 to 2}} + f.twoBits2 = ~2; // expected-warning {{implicit truncation from 'int' to bitfield changes value from -3 to 1}} + f.twoBits1 &= ~1; // no-warning + f.twoBits2 &= ~2; // no-warning +} + +void test8() { + enum E { A, B, C }; + struct { enum E x : 1; } f; + f.x = C; // expected-warning {{implicit truncation from 'int' to bitfield changes value from 2 to 0}} +} diff --git a/clang/test/Sema/constructor-attribute.c b/clang/test/Sema/constructor-attribute.c new file mode 100644 index 0000000..3825916 --- /dev/null +++ b/clang/test/Sema/constructor-attribute.c @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +int x __attribute__((constructor)); // expected-warning {{'constructor' attribute only applies to functions}} +int f() __attribute__((constructor)); +int f() __attribute__((constructor(1))); +int f() __attribute__((constructor(1,2))); // expected-error {{attribute takes no more than 1 argument}} +int f() __attribute__((constructor(1.0))); // expected-error {{'constructor' attribute requires parameter 1 to be an integer constant}} + +int x __attribute__((destructor)); // expected-warning {{'destructor' attribute only applies to functions}} +int f() __attribute__((destructor)); +int f() __attribute__((destructor(1))); +int f() __attribute__((destructor(1,2))); // expected-error {{attribute takes no more than 1 argument}} +int f() __attribute__((destructor(1.0))); // expected-error {{'destructor' attribute requires parameter 1 to be an integer constant}} + + diff --git a/clang/test/Sema/conversion-64-32.c b/clang/test/Sema/conversion-64-32.c new file mode 100644 index 0000000..3de20cb --- /dev/null +++ b/clang/test/Sema/conversion-64-32.c @@ -0,0 +1,19 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wshorten-64-to-32 -triple x86_64-apple-darwin %s + +int test0(long v) { + return v; // expected-warning {{implicit conversion loses integer precision}} +} + + +// rdar://9546171 +typedef int int4 __attribute__ ((vector_size(16))); +typedef long long long2 __attribute__((__vector_size__(16))); + +int4 test1(long2 a) { + int4 v127 = a; // no warning. + return v127; +} + +int test2(long v) { + return v / 2; // expected-warning {{implicit conversion loses integer precision: 'long' to 'int'}} +} diff --git a/clang/test/Sema/conversion.c b/clang/test/Sema/conversion.c new file mode 100644 index 0000000..a591ac0 --- /dev/null +++ b/clang/test/Sema/conversion.c @@ -0,0 +1,419 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wconversion \ +// RUN: -nostdsysteminc -nobuiltininc -isystem %S/Inputs \ +// RUN: -triple x86_64-apple-darwin %s -Wno-unreachable-code + +#include <conversion.h> + +#define BIG 0x7f7f7f7f7f7f7f7fL + +void test0(char c, short s, int i, long l, long long ll) { + c = c; + c = s; // expected-warning {{implicit conversion loses integer precision}} + c = i; // expected-warning {{implicit conversion loses integer precision}} + c = l; // expected-warning {{implicit conversion loses integer precision}} + s = c; + s = s; + s = i; // expected-warning {{implicit conversion loses integer precision}} + s = l; // expected-warning {{implicit conversion loses integer precision}} + i = c; + i = s; + i = i; + i = l; // expected-warning {{implicit conversion loses integer precision}} + l = c; + l = s; + l = i; + l = l; + + c = (char) 0; + c = (short) 0; + c = (int) 0; + c = (long) 0; + s = (char) 0; + s = (short) 0; + s = (int) 0; + s = (long) 0; + i = (char) 0; + i = (short) 0; + i = (int) 0; + i = (long) 0; + l = (char) 0; + l = (short) 0; + l = (int) 0; + l = (long) 0; + + c = (char) BIG; + c = (short) BIG; // expected-warning {{implicit conversion from 'short' to 'char' changes value}} + c = (int) BIG; // expected-warning {{implicit conversion from 'int' to 'char' changes value}} + c = (long) BIG; // expected-warning {{implicit conversion from 'long' to 'char' changes value}} + s = (char) BIG; + s = (short) BIG; + s = (int) BIG; // expected-warning {{implicit conversion from 'int' to 'short' changes value}} + s = (long) BIG; // expected-warning {{implicit conversion from 'long' to 'short' changes value}} + i = (char) BIG; + i = (short) BIG; + i = (int) BIG; + i = (long) BIG; // expected-warning {{implicit conversion from 'long' to 'int' changes value}} + l = (char) BIG; + l = (short) BIG; + l = (int) BIG; + l = (long) BIG; +} + +char test1(long long ll) { + return (long long) ll; // expected-warning {{implicit conversion loses integer precision}} +} +char test1_a(long long ll) { + return (long) ll; // expected-warning {{implicit conversion loses integer precision}} +} +char test1_b(long long ll) { + return (int) ll; // expected-warning {{implicit conversion loses integer precision}} +} +char test1_c(long long ll) { + return (short) ll; // expected-warning {{implicit conversion loses integer precision}} +} +char test1_d(long long ll) { + return (char) ll; +} +char test1_e(long long ll) { + return (long long) BIG; // expected-warning {{implicit conversion from 'long long' to 'char' changes value}} +} +char test1_f(long long ll) { + return (long) BIG; // expected-warning {{implicit conversion from 'long' to 'char' changes value}} +} +char test1_g(long long ll) { + return (int) BIG; // expected-warning {{implicit conversion from 'int' to 'char' changes value}} +} +char test1_h(long long ll) { + return (short) BIG; // expected-warning {{implicit conversion from 'short' to 'char' changes value}} +} +char test1_i(long long ll) { + return (char) BIG; +} + +short test2(long long ll) { + return (long long) ll; // expected-warning {{implicit conversion loses integer precision}} +} +short test2_a(long long ll) { + return (long) ll; // expected-warning {{implicit conversion loses integer precision}} +} +short test2_b(long long ll) { + return (int) ll; // expected-warning {{implicit conversion loses integer precision}} +} +short test2_c(long long ll) { + return (short) ll; +} +short test2_d(long long ll) { + return (char) ll; +} +short test2_e(long long ll) { + return (long long) BIG; // expected-warning {{implicit conversion from 'long long' to 'short' changes value}} +} +short test2_f(long long ll) { + return (long) BIG; // expected-warning {{implicit conversion from 'long' to 'short' changes value}} +} +short test2_g(long long ll) { + return (int) BIG; // expected-warning {{implicit conversion from 'int' to 'short' changes value}} +} +short test2_h(long long ll) { + return (short) BIG; +} +short test2_i(long long ll) { + return (char) BIG; +} + +int test3(long long ll) { + return (long long) ll; // expected-warning {{implicit conversion loses integer precision}} +} +int test3_b(long long ll) { + return (long) ll; // expected-warning {{implicit conversion loses integer precision}} +} +int test3_c(long long ll) { + return (int) ll; +} +int test3_d(long long ll) { + return (short) ll; +} +int test3_e(long long ll) { + return (char) ll; +} +int test3_f(long long ll) { + return (long long) BIG; // expected-warning {{implicit conversion from 'long long' to 'int' changes value}} +} +int test3_g(long long ll) { + return (long) BIG; // expected-warning {{implicit conversion from 'long' to 'int' changes value}} +} +int test3_h(long long ll) { + return (int) BIG; +} +int test3_i(long long ll) { + return (short) BIG; +} +int test3_j(long long ll) { + return (char) BIG; +} + +long test4(long long ll) { + return (long long) ll; +} +long test4_a(long long ll) { + return (long) ll; +} +long test4_b(long long ll) { + return (int) ll; +} +long test4_c(long long ll) { + return (short) ll; +} +long test4_d(long long ll) { + return (char) ll; +} +long test4_e(long long ll) { + return (long long) BIG; +} +long test4_f(long long ll) { + return (long) BIG; +} +long test4_g(long long ll) { + return (int) BIG; +} +long test4_h(long long ll) { + return (short) BIG; +} +long test4_i(long long ll) { + return (char) BIG; +} + +long long test5(long long ll) { + return (long long) ll; + return (long) ll; + return (int) ll; + return (short) ll; + return (char) ll; + return (long long) BIG; + return (long) BIG; + return (int) BIG; + return (short) BIG; + return (char) BIG; +} + +void takes_char(char); +void takes_short(short); +void takes_int(int); +void takes_long(long); +void takes_longlong(long long); +void takes_float(float); +void takes_double(double); +void takes_longdouble(long double); + +void test6(char v) { + takes_char(v); + takes_short(v); + takes_int(v); + takes_long(v); + takes_longlong(v); + takes_float(v); + takes_double(v); + takes_longdouble(v); +} + +void test7(short v) { + takes_char(v); // expected-warning {{implicit conversion loses integer precision}} + takes_short(v); + takes_int(v); + takes_long(v); + takes_longlong(v); + takes_float(v); + takes_double(v); + takes_longdouble(v); +} + +void test8(int v) { + takes_char(v); // expected-warning {{implicit conversion loses integer precision}} + takes_short(v); // expected-warning {{implicit conversion loses integer precision}} + takes_int(v); + takes_long(v); + takes_longlong(v); + takes_float(v); + takes_double(v); + takes_longdouble(v); +} + +void test9(long v) { + takes_char(v); // expected-warning {{implicit conversion loses integer precision}} + takes_short(v); // expected-warning {{implicit conversion loses integer precision}} + takes_int(v); // expected-warning {{implicit conversion loses integer precision}} + takes_long(v); + takes_longlong(v); + takes_float(v); + takes_double(v); + takes_longdouble(v); +} + +void test10(long long v) { + takes_char(v); // expected-warning {{implicit conversion loses integer precision}} + takes_short(v); // expected-warning {{implicit conversion loses integer precision}} + takes_int(v); // expected-warning {{implicit conversion loses integer precision}} + takes_long(v); + takes_longlong(v); + takes_float(v); + takes_double(v); + takes_longdouble(v); +} + +void test11(float v) { + takes_char(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_short(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_int(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_long(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_longlong(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_float(v); + takes_double(v); + takes_longdouble(v); +} + +void test12(double v) { + takes_char(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_short(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_int(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_long(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_longlong(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_float(v); // expected-warning {{implicit conversion loses floating-point precision}} + takes_double(v); + takes_longdouble(v); +} + +void test13(long double v) { + takes_char(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_short(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_int(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_long(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_longlong(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_float(v); // expected-warning {{implicit conversion loses floating-point precision}} + takes_double(v); // expected-warning {{implicit conversion loses floating-point precision}} + takes_longdouble(v); +} + +void test14(long l) { + // Fine because of the boolean whitelist. + char c; + c = (l == 4); + c = ((l <= 4) && (l >= 0)); + c = ((l <= 4) && (l >= 0)) || (l > 20); +} + +void test15(char c) { + c = c + 1 + c * 2; + c = (short) c + 1 + c * 2; // expected-warning {{implicit conversion loses integer precision}} +} + +// PR 5422 +extern void *test16_external; +void test16(void) { + int a = (unsigned long) &test16_external; // expected-warning {{implicit conversion loses integer precision}} +} + +// PR 5938 +void test17() { + union { + unsigned long long a : 8; + unsigned long long b : 32; + unsigned long long c; + } U; + + unsigned int x; + x = U.a; + x = U.b; + x = U.c; // expected-warning {{implicit conversion loses integer precision}} +} + +// PR 5939 +void test18() { + union { + unsigned long long a : 1; + unsigned long long b; + } U; + + int x; + x = (U.a ? 0 : 1); + x = (U.b ? 0 : 1); +} + +// None of these should warn. +unsigned char test19(unsigned long u64) { + unsigned char x1 = u64 & 0xff; + unsigned char x2 = u64 >> 56; + + unsigned char mask = 0xee; + unsigned char x3 = u64 & mask; + return x1 + x2 + x3; +} + +// <rdar://problem/7631400> +void test_7631400(void) { + // This should show up despite the caret being inside a macro substitution + char s = LONG_MAX; // expected-warning {{implicit conversion from 'long' to 'char' changes value}} +} + +// <rdar://problem/7676608>: assertion for compound operators with non-integral RHS +void f7676608(int); +void test_7676608(void) { + float q = 0.7f; + char c = 5; + f7676608(c *= q); +} + +// <rdar://problem/7904686> +void test_7904686(void) { + const int i = -1; + unsigned u1 = i; // expected-warning {{implicit conversion changes signedness}} + u1 = i; // expected-warning {{implicit conversion changes signedness}} + + unsigned u2 = -1; // expected-warning {{implicit conversion changes signedness}} + u2 = -1; // expected-warning {{implicit conversion changes signedness}} +} + +// <rdar://problem/8232669>: don't warn about conversions required by +// contexts in system headers +void test_8232669(void) { + unsigned bitset[20]; + SETBIT(bitset, 0); + + unsigned y = 50; + SETBIT(bitset, y); + +#define USER_SETBIT(set,bit) do { int i = bit; set[i/(8*sizeof(set[0]))] |= (1 << (i%(8*sizeof(set)))); } while(0) + USER_SETBIT(bitset, 0); // expected-warning 2 {{implicit conversion changes signedness}} +} + +// <rdar://problem/8559831> +enum E8559831a { E8559831a_val }; +enum E8559831b { E8559831b_val }; +typedef enum { E8559831c_val } E8559831c; +enum { E8559831d_val } value_d; + +void test_8559831_a(enum E8559831a value); +void test_8559831(enum E8559831b value_a, E8559831c value_c) { + test_8559831_a(value_a); // expected-warning{{implicit conversion from enumeration type 'enum E8559831b' to different enumeration type 'enum E8559831a'}} + enum E8559831a a1 = value_a; // expected-warning{{implicit conversion from enumeration type 'enum E8559831b' to different enumeration type 'enum E8559831a'}} + a1 = value_a; // expected-warning{{implicit conversion from enumeration type 'enum E8559831b' to different enumeration type 'enum E8559831a'}} + + test_8559831_a(E8559831b_val); // expected-warning{{implicit conversion from enumeration type 'enum E8559831b' to different enumeration type 'enum E8559831a'}} + enum E8559831a a1a = E8559831b_val; // expected-warning{{implicit conversion from enumeration type 'enum E8559831b' to different enumeration type 'enum E8559831a'}} + a1 = E8559831b_val; // expected-warning{{implicit conversion from enumeration type 'enum E8559831b' to different enumeration type 'enum E8559831a'}} + + test_8559831_a(value_c); // expected-warning{{implicit conversion from enumeration type 'E8559831c' to different enumeration type 'enum E8559831a'}} + enum E8559831a a2 = value_c; // expected-warning{{implicit conversion from enumeration type 'E8559831c' to different enumeration type 'enum E8559831a'}} + a2 = value_c; // expected-warning{{implicit conversion from enumeration type 'E8559831c' to different enumeration type 'enum E8559831a'}} + + test_8559831_a(value_d); + enum E8559831a a3 = value_d; + a3 = value_d; +} + +void test26(int si, long sl) { + si = sl % sl; // expected-warning {{implicit conversion loses integer precision: 'long' to 'int'}} + si = sl % si; + si = si % sl; + si = si / sl; + si = sl / si; // expected-warning {{implicit conversion loses integer precision: 'long' to 'int'}} +} diff --git a/clang/test/Sema/crash-invalid-array.c b/clang/test/Sema/crash-invalid-array.c new file mode 100644 index 0000000..a3bc03b --- /dev/null +++ b/clang/test/Sema/crash-invalid-array.c @@ -0,0 +1,17 @@ +// RUN: not %clang_cc1 -O1 %s -emit-llvm +// PR6913 + +#include <stdio.h> + +int main() +{ + int x[10][10]; + int (*p)[] = x; // expected-error {{invalid use of array with unspecified bounds} + + int i; + + for(i = 0; i < 10; ++i) + { + p[i][i] = i; + } +} diff --git a/clang/test/Sema/darwin-align-cast.c b/clang/test/Sema/darwin-align-cast.c new file mode 100644 index 0000000..2080974 --- /dev/null +++ b/clang/test/Sema/darwin-align-cast.c @@ -0,0 +1,24 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +typedef long unsigned int __darwin_size_t; +typedef long __darwin_ssize_t; +typedef __darwin_size_t size_t; +typedef __darwin_ssize_t ssize_t; + +struct cmsghdr {}; + +#if 0 +This code below comes from the following system headers: +sys/socket.h:#define CMSG_SPACE(l) (__DARWIN_ALIGN(sizeof(struct +cmsghdr)) + __DARWIN_ALIGN(l)) + +i386/_param.h:#define __DARWIN_ALIGN(p) ((__darwin_size_t)((char *)(p) ++ __DARWIN_ALIGNBYTES) &~ __DARWIN_ALIGNBYTES) +#endif + +ssize_t sendFileDescriptor(int fd, void *data, size_t nbytes, int sendfd) { + union { + char control[(((__darwin_size_t)((char *)(sizeof(struct cmsghdr)) + (sizeof(__darwin_size_t) - 1)) &~ (sizeof(__darwin_size_t) - 1)) + ((__darwin_size_t)((char *)(sizeof(int)) + (sizeof(__darwin_size_t) - 1)) &~ (sizeof(__darwin_size_t) - 1)))]; + } control_un; + return 0; +} + diff --git a/clang/test/Sema/decl-in-prototype.c b/clang/test/Sema/decl-in-prototype.c new file mode 100644 index 0000000..05b8e0a --- /dev/null +++ b/clang/test/Sema/decl-in-prototype.c @@ -0,0 +1,33 @@ +// RUN: %clang_cc1_only -verify %s + +const int AA = 5; + +int f1(enum {AA,BB} E) { + return BB; +} + +int f2(enum {AA=7,BB} E) { + return AA; +} + +struct a { +}; + +int f3(struct a { } *); // expected-warning {{will not be visible outside of this function}} + +struct A { struct b { int j; } t; }; // expected-note {{previous definition is here}} + +int f4(struct A { struct b { int j; } t; } *); // expected-warning {{declaration of 'struct A' will not be visible outside of this function}} expected-warning {{redefinition of 'b' will not be visible outside of this function}} + +struct aA { + struct ab { // expected-note {{previous definition is here}} expected-note {{previous definition is here}} + int j; + } b; +}; + +int f5(struct aA { struct ab { int j; } b; struct ab { char glorx; } glorx; } *); // expected-warning {{declaration of 'struct aA' will not be visible}} expected-warning {{redefinition of 'ab' will not be visible}} expected-warning {{redefinition of 'ab' will not be visible}} + +void f6(struct z {int b;} c) { // expected-warning {{declaration of 'struct z' will not be visible outside of this function}} + struct z d; + d.b = 4; +} diff --git a/clang/test/Sema/decl-invalid.c b/clang/test/Sema/decl-invalid.c new file mode 100644 index 0000000..f6fed3c --- /dev/null +++ b/clang/test/Sema/decl-invalid.c @@ -0,0 +1,28 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify + +// See Sema::ParsedFreeStandingDeclSpec about the double diagnostic +typedef union <anonymous> __mbstate_t; // expected-error {{declaration of anonymous union must be a definition}} expected-warning {{declaration does not declare anything}} + + +// PR2017 +void x(); +int a() { + int r[x()]; // expected-error {{size of array has non-integer type 'void'}} + + static y ?; // expected-error{{unknown type name 'y'}} \ + expected-error{{expected identifier or '('}} +} + +int; // expected-warning {{declaration does not declare anything}} +typedef int; // expected-warning {{declaration does not declare anything}} +const int; // expected-warning {{declaration does not declare anything}} +struct; // expected-error {{declaration of anonymous struct must be a definition}} // expected-warning {{declaration does not declare anything}} +typedef int I; +I; // expected-warning {{declaration does not declare anything}} + + + +// rdar://6880449 +register int test1; // expected-error {{illegal storage class on file-scoped variable}} +register int test2 __asm__("edi"); // expected-error {{global register variables are not supported}} + diff --git a/clang/test/Sema/decl-type-merging.c b/clang/test/Sema/decl-type-merging.c new file mode 100644 index 0000000..259b0dd --- /dev/null +++ b/clang/test/Sema/decl-type-merging.c @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 -fsyntax-only -std=c99 -verify -pedantic %s + +int x[10]; +int x[] = {1,2,3}; +int testx[(sizeof(x) == sizeof(int) * 10) ? 1 : -1]; + +int (*a)(int (*x)[10], int (*y)[]); +int (*a)(int (*x)[], int (*y)[5]); +void b() { + int x[10], y[5]; + a(&x, &y); + a(&y, &y); // expected-warning {{incompatible pointer}} + a(&x, &x); // expected-warning {{incompatible pointer}} +} + + diff --git a/clang/test/Sema/declspec.c b/clang/test/Sema/declspec.c new file mode 100644 index 0000000..7354028 --- /dev/null +++ b/clang/test/Sema/declspec.c @@ -0,0 +1,38 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only +typedef char T[4]; + +T foo(int n, int m) { } // expected-error {{cannot return array type}} + +void foof(const char *, ...) __attribute__((__format__(__printf__, 1, 2))), barf (void); + +int typedef validTypeDecl() { } // expected-error {{function definition declared 'typedef'}} + +struct _zend_module_entry { } // expected-error {{expected ';' after struct}} +int gv1; +typedef struct _zend_function_entry { } // expected-error {{expected ';' after struct}} \ + // expected-warning {{declaration does not declare anything}} +int gv2; + +static void buggy(int *x) { } + +// Type qualifiers. +typedef int f(void); +typedef f* fptr; +const f* v1; // expected-warning {{qualifier on function type 'f' (aka 'int (void)') has unspecified behavior}} +__restrict__ f* v2; // expected-error {{restrict requires a pointer or reference ('f' (aka 'int (void)') is invalid)}} +__restrict__ fptr v3; // expected-error {{pointer to function type 'f' (aka 'int (void)') may not be 'restrict' qualified}} +f *__restrict__ v4; // expected-error {{pointer to function type 'f' (aka 'int (void)') may not be 'restrict' qualified}} + +restrict struct hallo; // expected-error {{restrict requires a pointer or reference}} + +// PR6180 +struct test1 { +} // expected-error {{expected ';' after struct}} + +void test2() {} + + +// PR6423 +struct test3s { +} // expected-error {{expected ';' after struct}} +typedef int test3g; diff --git a/clang/test/Sema/default.c b/clang/test/Sema/default.c new file mode 100644 index 0000000..429e63a --- /dev/null +++ b/clang/test/Sema/default.c @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +void f5 (int z) { + if (z) + default: // expected-error {{not in switch statement}} + ; +} + diff --git a/clang/test/Sema/default1.c b/clang/test/Sema/default1.c new file mode 100644 index 0000000..631e848 --- /dev/null +++ b/clang/test/Sema/default1.c @@ -0,0 +1,2 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +void f(int i = 0); // expected-error {{C does not support default arguments}} diff --git a/clang/test/Sema/deref.c b/clang/test/Sema/deref.c new file mode 100644 index 0000000..845b286 --- /dev/null +++ b/clang/test/Sema/deref.c @@ -0,0 +1,44 @@ +/* RUN: %clang_cc1 -fsyntax-only -verify -std=c90 -pedantic %s + */ +void +foo (void) +{ + struct b; + struct b* x = 0; + struct b* y = &*x; +} + +void foo2 (void) +{ + typedef int (*arrayptr)[]; + arrayptr x = 0; + arrayptr y = &*x; +} + +void foo3 (void) +{ + void* x = 0; + void* y = &*x; /* expected-warning{{address of an expression of type 'void'}} */ +} + +extern const void cv1; + +const void *foo4 (void) +{ + return &cv1; +} + +extern void cv2; +void *foo5 (void) +{ + return &cv2; /* expected-warning{{address of an expression of type 'void'}} */ +} + +typedef const void CVT; +extern CVT cv3; + +const void *foo6 (void) +{ + return &cv3; +} + diff --git a/clang/test/Sema/designated-initializers.c b/clang/test/Sema/designated-initializers.c new file mode 100644 index 0000000..c9a8482 --- /dev/null +++ b/clang/test/Sema/designated-initializers.c @@ -0,0 +1,279 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-unknown-unknown %s + +int complete_array_from_init[] = { 1, 2, [10] = 5, 1, 2, [5] = 2, 6 }; + +int complete_array_from_init_check[((sizeof(complete_array_from_init) / sizeof(int)) == 13)? 1 : -1]; + +int iarray[10] = { + [0] = 1, + [1 ... 5] = 2, + [ 6 ... 6 ] = 3, + [ 8 ... 7 ] = 4, // expected-error{{array designator range [8, 7] is empty}} + [10] = 5, + [-1] = 6 // expected-error{{array designator value '-1' is negative}} +}; + +int iarray2[10] = { + [10] = 1, // expected-error{{array designator index (10) exceeds array bounds (10)}} +}; + +int iarray3[10] = { + [3] 2, // expected-warning{{use of GNU 'missing =' extension in designator}} + [5 ... 12] = 2 // expected-error{{array designator index (12) exceeds array bounds (10)}} +}; + +struct point { + double x; + double y; +}; + +struct point p1 = { + .y = 1.0, + x: 2.0, // expected-warning{{}} + .a = 4.0, // expected-error{{field designator 'a' does not refer to any field in type 'struct point'}} +}; + +struct point p2 = { + [1] = 1.0 // expected-error{{array designator cannot initialize non-array type}} +}; + +struct point array[10] = { + [0].x = 1.0, + [1].y = 2.0, + [2].z = 3.0, // expected-error{{field designator 'z' does not refer to any field in type 'struct point'}} +}; + +struct point array2[10] = { + [10].x = 2.0, // expected-error{{array designator index (10) exceeds array bounds (10)}} + [4 ... 5].y = 2.0, + [4 ... 6] = { .x = 3, .y = 4.0 } +}; + +struct point array3[10] = { + .x = 5 // expected-error{{field designator cannot initialize a non-struct, non-union type}} +}; + +struct rect { + struct point top_left; + struct point bottom_right; +}; + +struct rect window = { .top_left.x = 1.0 }; + +struct rect windows[] = { + [2].top_left = { 1.0, 2.0 }, + [4].bottom_right = { .y = 1.0 }, + { { .y = 7.0, .x = 8.0 }, { .x = 5.0 } }, + [3] = { .top_left = { 1.1, 2.2 }, .bottom_right = { .y = 1.1 } } +}; + +int windows_size[((sizeof(windows) / sizeof(struct rect)) == 6)? 1 : -1]; + +struct rect windows_bad[3] = { + [2].top_left = { { .x = 1.1 } }, // expected-error{{designator in initializer for scalar type}} + [1].top_left = { .x = 1.1 } +}; + +struct gui { + struct rect windows[10]; +}; + +struct gui gui[] = { + [5].windows[3].top_left.x = { 7.0 } // expected-warning{{braces around scalar initializer}} +}; + +struct translator { + struct wonky { int * ptr; } wonky ; + struct rect window; + struct point offset; +} tran = { + .window = { .top_left = { 1.0, 2.0 } }, + { .x = 5.0, .y = 6.0 }, + .wonky = { 0 } +}; + +int anint; +struct {int x,*y;} z[] = {[0].x = 2, &z[0].x}; + +struct outer { struct inner { int x, *y; } in, *inp; } zz[] = { + [0].in.x = 2, &zz[0].in.x, &zz[0].in, + 0, &anint, &zz[1].in, + [3].in = { .y = &anint, .x = 17 }, + [7].in.y = &anint, &zz[0].in, + [4].in.y = &anint, [5].in.x = 12 +}; + +int zz_sizecheck[sizeof(zz) / sizeof(struct outer) == 8? 1 : -1 ]; + +struct disklabel_ops { + struct {} type; + int labelsize; +}; + +struct disklabel_ops disklabel64_ops = { + .labelsize = sizeof(struct disklabel_ops) +}; + +// PR clang/3378 +int bitwidth[] = { [(long long int)1] = 5, [(short int)2] = 2 }; +int a[]= { [sizeof(int)] = 0 }; +int a2[]= { [0 ... sizeof(int)] = 0 }; + +// Test warnings about initializers overriding previous initializers +struct X { + int a, b, c; +}; + +int counter = 0; +int get8() { ++counter; return 8; } + +void test() { + struct X xs[] = { + [0] = (struct X){1, 2}, // expected-note{{previous initialization is here}} + [0].c = 3, // expected-warning{{subobject initialization overrides initialization of other fields within its enclosing subobject}} + (struct X) {4, 5, 6}, // expected-note{{previous initialization is here}} + [1].b = get8(), // expected-warning{{subobject initialization overrides initialization of other fields within its enclosing subobject}} + [0].b = 8 + }; +} + +// FIXME: How do we test that this initializes the long properly? +union { char c; long l; } u1 = { .l = 0xFFFF }; + +extern float global_float; + +struct XX { int a, *b; }; +struct XY { int before; struct XX xx, *xp; float* after; } xy[] = { + 0, 0, &xy[0].xx.a, &xy[0].xx, &global_float, + [1].xx = 0, &xy[1].xx.a, &xy[1].xx, &global_float, + 0, // expected-note{{previous initialization is here}} + 0, // expected-note{{previous initialization is here}} + [2].before = 0, // expected-warning{{initializer overrides prior initialization of this subobject}} + 0, // expected-warning{{initializer overrides prior initialization of this subobject}} + &xy[2].xx.a, &xy[2].xx, &global_float +}; + +// PR3519 +struct foo { + int arr[10]; +}; + +struct foo Y[10] = { + [1] .arr [1] = 2, + [4] .arr [2] = 4 +}; + +struct bar { + struct foo f; + float *arr[10]; +}; + +extern float f; +struct bar saloon = { + .f.arr[3] = 1, + .arr = { &f } +}; + +typedef unsigned char u_char; +typedef unsigned short u_short; + +union wibble { + u_char arr1[6]; + u_short arr2[3]; +}; + +const union wibble wobble = { .arr2[0] = 0xffff, + .arr2[1] = 0xffff, + .arr2[2] = 0xffff }; + +const union wibble wobble2 = { .arr2 = {4, 5, 6}, 7 }; // expected-warning{{excess elements in union initializer}} + +// PR3778 +struct s { + union { int i; }; +}; +struct s si = { + { .i = 1 } +}; + +double d0; +char c0; +float f0; +int i0; + +struct Enigma { + union { + struct { + struct { + double *double_ptr; + char *string; + }; + float *float_ptr; + }; + int *int_ptr; + }; + char *string2; +}; + +struct Enigma enigma = { + .double_ptr = &d0, &c0, + &f0, // expected-note{{previous}} + &c0, + .float_ptr = &f0 // expected-warning{{overrides}} +}; + + +/// PR4073 +/// Should use evaluate to fold aggressively and emit a warning if not an ice. +extern int crazy_x; + +int crazy_Y[] = { + [ 0 ? crazy_x : 4] = 1 +}; + +// PR5843 +struct expr { + int nargs; + union { + unsigned long int num; + struct expr *args[3]; + } val; +}; + +struct expr expr0 = { + .nargs = 2, + .val = { + .args = { + [0] = (struct expr *)0, + [1] = (struct expr *)0 + } + } +}; + +// PR6955 + +struct ds { + struct { + struct { + unsigned int a; + }; + unsigned int b; + struct { + unsigned int c; + }; + }; +}; + +// C1X lookup-based anonymous member init cases +struct ds ds0 = { + { { + .a = 1 // expected-note{{previous initialization is here}} + } }, + .a = 2, // expected-warning{{initializer overrides prior initialization of this subobject}} + .b = 3 +}; +struct ds ds1 = { .c = 0 }; +struct ds ds2 = { { { + .a = 0, + .b = 1 // expected-error{{field designator 'b' does not refer to any field}} +} } }; diff --git a/clang/test/Sema/dllimport-dllexport.c b/clang/test/Sema/dllimport-dllexport.c new file mode 100644 index 0000000..610059e --- /dev/null +++ b/clang/test/Sema/dllimport-dllexport.c @@ -0,0 +1,37 @@ +// RUN: %clang_cc1 -triple i386-mingw32 -fsyntax-only -verify %s +// RUN: %clang_cc1 -triple x86_64-mingw32 -fsyntax-only -verify %s + +inline void __attribute__((dllexport)) foo1(){} // expected-warning{{dllexport attribute ignored}} +inline void __attribute__((dllimport)) foo2(){} // expected-warning{{dllimport attribute ignored}} + +void __attribute__((dllimport)) foo3(){} // expected-error{{dllimport attribute can be applied only to symbol declaration}} + +void __attribute__((dllimport, dllexport)) foo4(); // expected-warning{{dllimport attribute ignored}} + +void __attribute__((dllexport)) foo5(); +void __attribute__((dllimport)) foo5(); // expected-warning{{dllimport attribute ignored}} + +typedef int __attribute__((dllexport)) type6; // expected-warning{{'dllexport' attribute only applies to variables and functions}} + +typedef int __attribute__((dllimport)) type7; // expected-warning{{'dllimport' attribute only applies to variables and functions}} + +void __attribute__((dllimport)) foo6(); +void foo6(){} // expected-warning {{'foo6' redeclared without dllimport attribute: previous dllimport ignored}} + +// PR6269 +inline void __declspec(dllexport) foo7(){} // expected-warning{{dllexport attribute ignored}} +inline void __declspec(dllimport) foo8(){} // expected-warning{{dllimport attribute ignored}} + +void __declspec(dllimport) foo9(){} // expected-error{{dllimport attribute can be applied only to symbol declaration}} + +void __declspec(dllimport) __declspec(dllexport) foo10(); // expected-warning{{dllimport attribute ignored}} + +void __declspec(dllexport) foo11(); +void __declspec(dllimport) foo11(); // expected-warning{{dllimport attribute ignored}} + +typedef int __declspec(dllexport) type1; // expected-warning{{'dllexport' attribute only applies to variables and functions}} + +typedef int __declspec(dllimport) type2; // expected-warning{{'dllimport' attribute only applies to variables and functions}} + +void __declspec(dllimport) foo12(); +void foo12(){} // expected-warning {{'foo12' redeclared without dllimport attribute: previous dllimport ignored}} diff --git a/clang/test/Sema/enum-packed.c b/clang/test/Sema/enum-packed.c new file mode 100644 index 0000000..0eb6c14 --- /dev/null +++ b/clang/test/Sema/enum-packed.c @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// PR7477 +enum __attribute__((packed)) E { + Ea, Eb, Ec, Ed +}; + +void test_E(enum E e) { + switch (e) { + case Ea: + case Eb: + case Ec: + case Ed: + break; + } +} diff --git a/clang/test/Sema/enum.c b/clang/test/Sema/enum.c new file mode 100644 index 0000000..fc2b491 --- /dev/null +++ b/clang/test/Sema/enum.c @@ -0,0 +1,121 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify -pedantic +enum e {A, + B = 42LL << 32, // expected-warning {{ISO C restricts enumerator values to range of 'int'}} + C = -4, D = 12456 }; + +enum f { a = -2147483648, b = 2147483647 }; // ok. + +enum g { // too negative + c = -2147483649, // expected-warning {{ISO C restricts enumerator values to range of 'int'}} + d = 2147483647 }; +enum h { e = -2147483648, // too pos + f = 2147483648, // expected-warning {{ISO C restricts enumerator values to range of 'int'}} + i = 0xFFFF0000 // expected-warning {{too large}} +}; + +// minll maxull +enum x // expected-warning {{enumeration values exceed range of largest integer}} +{ y = -9223372036854775807LL-1, // expected-warning {{ISO C restricts enumerator values to range of 'int'}} +z = 9223372036854775808ULL }; // expected-warning {{ISO C restricts enumerator values to range of 'int'}} + +int test() { + return sizeof(enum e) ; +} + +enum gccForwardEnumExtension ve; // expected-warning{{ISO C forbids forward references to 'enum' types}} \ +// expected-error{{tentative definition has type 'enum gccForwardEnumExtension' that is never completed}} \ +// expected-note{{forward declaration of 'enum gccForwardEnumExtension'}} + +int test2(int i) +{ + ve + i; // expected-error{{invalid operands to binary expression}} +} + +// PR2020 +union u0; // expected-note {{previous use is here}} +enum u0 { U0A }; // expected-error {{use of 'u0' with tag type that does not match previous declaration}} + + +// rdar://6095136 +extern enum some_undefined_enum ve2; // expected-warning {{ISO C forbids forward references to 'enum' types}} + +void test4() { + for (; ve2;) // expected-error {{statement requires expression of scalar type}} + ; + (_Bool)ve2; // expected-error {{arithmetic or pointer type is required}} + + for (; ;ve2) // expected-warning {{expression result unused}} + ; + (void)ve2; + ve2; // expected-warning {{expression result unused}} +} + +// PR2416 +enum someenum {}; // expected-error {{use of empty enum}} + +// <rdar://problem/6093889> +enum e0 { // expected-note {{previous definition is here}} + E0 = sizeof(enum e0 { E1 }), // expected-error {{nested redefinition}} +}; + +// PR3173 +enum { PR3173A, PR3173B = PR3173A+50 }; + +// PR2753 +void foo() { + enum xpto; // expected-warning{{ISO C forbids forward references to 'enum' types}} + enum xpto; // expected-warning{{ISO C forbids forward references to 'enum' types}} +} + +// <rdar://problem/6503878> +typedef enum { X = 0 }; // expected-warning{{typedef requires a name}} + + +enum NotYetComplete { // expected-note{{definition of 'enum NotYetComplete' is not complete until the closing '}'}} + NYC1 = sizeof(enum NotYetComplete) // expected-error{{invalid application of 'sizeof' to an incomplete type 'enum NotYetComplete'}} +}; + +/// PR3688 +struct s1 { + enum e1 (*bar)(void); // expected-warning{{ISO C forbids forward references to 'enum' types}} +}; + +enum e1 { YES, NO }; + +static enum e1 badfunc(struct s1 *q) { + return q->bar(); +} + + +// Make sure we don't a.k.a. anonymous enums. +typedef enum { + an_enumerator = 20 +} an_enum; +char * s = (an_enum) an_enumerator; // expected-warning {{incompatible integer to pointer conversion initializing 'char *' with an expression of type 'an_enum'}} + +// PR4515 +enum PR4515 {PR4515a=1u,PR4515b=(PR4515a-2)/2}; +int CheckPR4515[PR4515b==0?1:-1]; + +// PR7911 +extern enum PR7911T PR7911V; // expected-warning{{ISO C forbids forward references to 'enum' types}} +void PR7911F() { + switch (PR7911V); // expected-error {{statement requires expression of integer type}} +} + +char test5[__has_feature(enumerator_attributes) ? 1 : -1]; + +// PR8694 +// rdar://8707031 +void PR8694(int* e) // expected-note {{passing argument to parameter 'e' here}} +{ +} + +void crash(enum E* e) // expected-warning {{declaration of 'enum E' will not be visible outside of this function}} \ + // expected-warning {{ISO C forbids forward references to 'enum' types}} +{ + PR8694(e); // expected-warning {{incompatible pointer types passing 'enum E *' to parameter of type 'int *'}} +} + +typedef enum { NegativeShort = (short)-1 } NegativeShortEnum; +int NegativeShortTest[NegativeShort == -1 ? 1 : -1]; diff --git a/clang/test/Sema/expr-address-of.c b/clang/test/Sema/expr-address-of.c new file mode 100644 index 0000000..2b8cfbf --- /dev/null +++ b/clang/test/Sema/expr-address-of.c @@ -0,0 +1,120 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only +struct xx { int bitf:1; }; + +struct entry { struct xx *whatever; + int value; + int bitf:1; }; +void add_one(int *p) { (*p)++; } + +void test() { + register struct entry *p; + add_one(&p->value); + struct entry pvalue; + add_one(&p->bitf); // expected-error {{address of bit-field requested}} + add_one(&pvalue.bitf); // expected-error {{address of bit-field requested}} + add_one(&p->whatever->bitf); // expected-error {{address of bit-field requested}} +} + +void foo() { + register int x[10]; + &x[10]; // expected-error {{address of register variable requested}} + + register int *y; + + int *x2 = &y; // expected-error {{address of register variable requested}} + int *x3 = &y[10]; +} + +void testVectorComponentAccess() { + typedef float v4sf __attribute__ ((vector_size (16))); + static v4sf q; + float* r = &q[0]; // expected-error {{address of vector element requested}} +} + +typedef __attribute__(( ext_vector_type(4) )) float float4; + +float *testExtVectorComponentAccess(float4 x) { + return &x.w; // expected-error {{address of vector element requested}} +} + +void f0() { + register int *x0; + int *_dummy0 = &(*x0); + + register int *x1; + int *_dummy1 = &(*(x1 + 1)); +} + +// FIXME: The checks for this function are broken; we should error +// on promoting a register array to a pointer! (C99 6.3.2.1p3) +void f1() { + register int x0[10]; + int *_dummy00 = x0; // fixme-error {{address of register variable requested}} + int *_dummy01 = &(*x0); // fixme-error {{address of register variable requested}} + + register int x1[10]; + int *_dummy1 = &(*(x1 + 1)); // fixme-error {{address of register variable requested}} + + register int *x2; + int *_dummy2 = &(*(x2 + 1)); + + register int x3[10][10][10]; + int (*_dummy3)[10] = &x3[0][0]; // expected-error {{address of register variable requested}} + + register struct { int f0[10]; } x4; + int *_dummy4 = &x4.f0[2]; // expected-error {{address of register variable requested}} +} + +void f2() { + register int *y; + + int *_dummy0 = &y; // expected-error {{address of register variable requested}} + int *_dummy1 = &y[10]; +} + +void f3() { + extern void f4(); + void (*_dummy0)() = &****f4; +} + +void f4() { + register _Complex int x; + + int *_dummy0 = &__real__ x; // expected-error {{address of register variable requested}} +} + +void f5() { + register int arr[2]; + + /* This is just here because if we happened to support this as an + lvalue we would need to give a warning. Note that gcc warns about + this as a register before it warns about it as an invalid + lvalue. */ + int *_dummy0 = &(int*) arr; // expected-error {{address expression must be an lvalue or a function designator}} + int *_dummy1 = &(arr + 1); // expected-error {{address expression must be an lvalue or a function designator}} +} + +void f6(register int x) { + int * dummy0 = &x; // expected-error {{address of register variable requested}} +} + +char* f7() { + register struct {char* x;} t1 = {"Hello"}; + char* dummy1 = &(t1.x[0]); + + struct {int a : 10;} t2; + int* dummy2 = &(t2.a); // expected-error {{address of bit-field requested}} + + void* t3 = &(*(void*)0); +} + +void f8() { + void *dummy0 = &f8(); // expected-error {{address expression must be an lvalue or a function designator}} + + extern void v; + void *dummy1 = &(1 ? v : f8()); // expected-error {{address expression must be an lvalue or a function designator}} + + void *dummy2 = &(f8(), v); // expected-error {{address expression must be an lvalue or a function designator}} + + void *dummy3 = &({ ; }); // expected-error {{address expression must be an lvalue or a function designator}} +} diff --git a/clang/test/Sema/expr-comma-c99.c b/clang/test/Sema/expr-comma-c99.c new file mode 100644 index 0000000..d0883ba --- /dev/null +++ b/clang/test/Sema/expr-comma-c99.c @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify -std=c99 +// rdar://6095180 + +struct s { char c[17]; }; +extern struct s foo(void); + +struct s a, b, c; + +int A[sizeof((foo().c)) == 17 ? 1 : -1]; +int B[sizeof((a.c)) == 17 ? 1 : -1]; + + +// comma does array/function promotion in c99. +int X[sizeof(0, (foo().c)) == sizeof(char*) ? 1 : -1]; +int Y[sizeof(0, (a,b).c) == sizeof(char*) ? 1 : -1]; +int Z[sizeof(0, (a=b).c) == sizeof(char*) ? 1 : -1]; + diff --git a/clang/test/Sema/expr-comma.c b/clang/test/Sema/expr-comma.c new file mode 100644 index 0000000..d3e4020 --- /dev/null +++ b/clang/test/Sema/expr-comma.c @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify -std=c89 +// rdar://6095180 + +struct s { char c[17]; }; +extern struct s foo(void); + +struct s a, b, c; + +int A[sizeof((foo().c)) == 17 ? 1 : -1]; +int B[sizeof((a.c)) == 17 ? 1 : -1]; + + +// comma does not promote array/function in c90 unless they are lvalues. +int W[sizeof(0, a.c) == sizeof(char*) ? 1 : -1]; +int X[sizeof(0, (foo().c)) == 17 ? 1 : -1]; +int Y[sizeof(0, (a,b).c) == 17 ? 1 : -1]; +int Z[sizeof(0, (a=b).c) == 17 ? 1 : -1]; diff --git a/clang/test/Sema/exprs.c b/clang/test/Sema/exprs.c new file mode 100644 index 0000000..72cff65 --- /dev/null +++ b/clang/test/Sema/exprs.c @@ -0,0 +1,240 @@ +// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only + +// PR 8876 - don't warn about trivially unreachable null derefs. Note that +// we put this here because the reachability analysis only kicks in for +// suppressing false positives when code has no errors. +#define PR8876(err_ptr) do {\ + if (err_ptr) *(int*)(err_ptr) = 1;\ + } while (0) + +#define PR8876_pos(err_ptr) do {\ + if (!err_ptr) *(int*)(err_ptr) = 1;\ + } while (0) + + +// Test that we don't report divide-by-zero errors in unreachable code. +// This test should be left as is, as it also tests CFG functionality. +void radar9171946() { + if (0) { + 0 / (0 ? 1 : 0); // expected-warning {{expression result unused}} + } +} + +int test_pr8876() { + PR8876(0); // no-warning + PR8876_pos(0); // expected-warning{{indirection of non-volatile null pointer will be deleted, not trap}} expected-note{{consider using __builtin_trap() or qualifying pointer with 'volatile'}} + return 0; +} + +// PR 8183 - Handle null pointer constants on the left-side of the '&&', and reason about +// this when determining the reachability of the null pointer dereference on the right side. +void pr8183(unsigned long long test) +{ + (void)((((void*)0)) && (*((unsigned long long*)(((void*)0))) = ((unsigned long long)((test)) % (unsigned long long)((1000000000))))); // no-warning + (*((unsigned long long*)(((void*)0))) = ((unsigned long long)((test)) % (unsigned long long)((1000000000)))); // expected-warning {{indirection of non-volatile null pointer will be deleted, not trap}} expected-note {{consider using __builtin_trap() or qualifying pointer with 'volatile'}} +} + +// PR1966 +_Complex double test1() { + return __extension__ 1.0if; +} + +_Complex double test2() { + return 1.0if; // expected-warning {{imaginary constants are an extension}} +} + +// rdar://6097308 +void test3() { + int x; + (__extension__ x) = 10; +} + +// rdar://6162726 +void test4() { + static int var; + var =+ 5; // expected-warning {{use of unary operator that may be intended as compound assignment (+=)}} + var =- 5; // expected-warning {{use of unary operator that may be intended as compound assignment (-=)}} + var = +5; // no warning when space between the = and +. + var = -5; + + var =+5; // no warning when the subexpr of the unary op has no space before it. + var =-5; + +#define FIVE 5 + var=-FIVE; // no warning with macros. + var=-FIVE; +} + +// rdar://6319320 +void test5(int *X, float *P) { + (float*)X = P; // expected-error {{assignment to cast is illegal, lvalue casts are not supported}} +#define FOO ((float*) X) + FOO = P; // expected-error {{assignment to cast is illegal, lvalue casts are not supported}} +} + +void test6() { + int X; + X(); // expected-error {{called object type 'int' is not a function or function pointer}} +} + +void test7(int *P, _Complex float Gamma) { + P = (P-42) + Gamma*4; // expected-error {{invalid operands to binary expression ('int *' and '_Complex float')}} +} + + +// rdar://6095061 +int test8(void) { + int i; + __builtin_choose_expr (0, 42, i) = 10; + return i; +} + + +// PR3386 +struct f { int x : 4; float y[]; }; +int test9(struct f *P) { + int R; + R = __alignof(P->x); // expected-error {{invalid application of '__alignof' to bit-field}} + R = __alignof(P->y); // ok. + R = sizeof(P->x); // expected-error {{invalid application of 'sizeof' to bit-field}} + return R; +} + +// PR3562 +void test10(int n,...) { + struct S { + double a[n]; // expected-error {{fields must have a constant size}} + } s; + double x = s.a[0]; // should not get another error here. +} + + +#define MYMAX(A,B) __extension__ ({ __typeof__(A) __a = (A); __typeof__(B) __b = (B); __a < __b ? __b : __a; }) + +struct mystruct {int A; }; +void test11(struct mystruct P, float F) { + MYMAX(P, F); // expected-error {{invalid operands to binary expression ('typeof (P)' (aka 'struct mystruct') and 'typeof (F)' (aka 'float'))}} +} + +// PR3753 +int test12(const char *X) { + return X == "foo"; // expected-warning {{comparison against a string literal is unspecified (use strncmp instead)}} +} + +int test12b(const char *X) { + return sizeof(X == "foo"); // no-warning +} + +// rdar://6719156 +void test13( + void (^P)()) { // expected-error {{blocks support disabled - compile with -fblocks}} + P(); + P = ^(){}; // expected-error {{blocks support disabled - compile with -fblocks}} +} + +void test14() { + typedef long long __m64 __attribute__((__vector_size__(8))); + typedef short __v4hi __attribute__((__vector_size__(8))); + + // Ok. + __v4hi a; + __m64 mask = (__m64)((__v4hi)a > (__v4hi)a); +} + + +// PR5242 +typedef unsigned long *test15_t; + +test15_t test15(void) { + return (test15_t)0 + (test15_t)0; // expected-error {{invalid operands to binary expression ('test15_t' (aka 'unsigned long *') and 'test15_t')}} +} + +// rdar://7446395 +void test16(float x) { x == ((void*) 0); } // expected-error {{invalid operands to binary expression}} + +// PR6004 +void test17(int x) { + x = x / 0; // expected-warning {{division by zero is undefined}} + x = x % 0; // expected-warning {{remainder by zero is undefined}} + x /= 0; // expected-warning {{division by zero is undefined}} + x %= 0; // expected-warning {{remainder by zero is undefined}} + + x = sizeof(x/0); // no warning. +} + +// PR6501 +void test18_a(int a); // expected-note 2 {{'test18_a' declared here}} +void test18(int b) { + test18_a(b, b); // expected-error {{too many arguments to function call, expected 1, have 2}} + test18_a(); // expected-error {{too few arguments to function call, expected 1, have 0}} +} + +// PR7569 +void test19() { + *(int*)0 = 0; // expected-warning {{indirection of non-volatile null pointer}} \ + // expected-note {{consider using __builtin_trap}} + *(volatile int*)0 = 0; // Ok. + + // rdar://9269271 + int x = *(int*)0; // expected-warning {{indirection of non-volatile null pointer}} \ + // expected-note {{consider using __builtin_trap}} + int x2 = *(volatile int*)0; // Ok. + int *p = &(*(int*)0); // Ok; +} + +int test20(int x) { + return x && 4; // expected-warning {{use of logical '&&' with constant operand}} \ + // expected-note {{use '&' for a bitwise operation}} \ + // expected-note {{remove constant to silence this warning}} + + return x && sizeof(int) == 4; // no warning, RHS is logical op. + + // no warning, this is an idiom for "true" in old C style. + return x && (signed char)1; + + return x || 0; + return x || 1; + return x || -1; // expected-warning {{use of logical '||' with constant operand}} \ + // expected-note {{use '|' for a bitwise operation}} + return x || 5; // expected-warning {{use of logical '||' with constant operand}} \ + // expected-note {{use '|' for a bitwise operation}} + return x && 0; + return x && 1; + return x && -1; // expected-warning {{use of logical '&&' with constant operand}} \ + // expected-note {{use '&' for a bitwise operation}} \ + // expected-note {{remove constant to silence this warning}} + return x && 5; // expected-warning {{use of logical '&&' with constant operand}} \ + // expected-note {{use '&' for a bitwise operation}} \ + // expected-note {{remove constant to silence this warning}} + return x || (0); + return x || (1); + return x || (-1); // expected-warning {{use of logical '||' with constant operand}} \ + // expected-note {{use '|' for a bitwise operation}} + return x || (5); // expected-warning {{use of logical '||' with constant operand}} \ + // expected-note {{use '|' for a bitwise operation}} + return x && (0); + return x && (1); + return x && (-1); // expected-warning {{use of logical '&&' with constant operand}} \ + // expected-note {{use '&' for a bitwise operation}} \ + // expected-note {{remove constant to silence this warning}} + return x && (5); // expected-warning {{use of logical '&&' with constant operand}} \ + // expected-note {{use '&' for a bitwise operation}} \ + // expected-note {{remove constant to silence this warning}} + +} + +struct Test21; // expected-note 2 {{forward declaration}} +void test21(volatile struct Test21 *ptr) { + void test21_help(void); + (test21_help(), *ptr); // expected-error {{incomplete type 'struct Test21' where a complete type is required}} + (*ptr, test21_help()); // expected-error {{incomplete type 'struct Test21' where a complete type is required}} +} + +// Make sure we do function/array decay. +void test22() { + if ("help") + (void) 0; + + if (test22) + (void) 0; +} diff --git a/clang/test/Sema/ext_vector_casts.c b/clang/test/Sema/ext_vector_casts.c new file mode 100644 index 0000000..848ec1f --- /dev/null +++ b/clang/test/Sema/ext_vector_casts.c @@ -0,0 +1,52 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -fno-lax-vector-conversions %s + +typedef __attribute__(( ext_vector_type(2) )) float float2; +typedef __attribute__(( ext_vector_type(4) )) int int4; +typedef __attribute__(( ext_vector_type(8) )) short short8; +typedef __attribute__(( ext_vector_type(4) )) float float4; +typedef float t3 __attribute__ ((vector_size (16))); + +static void test() { + float2 vec2; + float4 vec4, vec4_2; + int4 ivec4; + short8 ish8; + t3 vec4_3; + int *ptr; + int i; + + vec4 = 5.0f; + vec4 = (float4)5.0f; + vec4 = (float4)5; + vec4 = (float4)vec4_3; + + ivec4 = (int4)5.0f; + ivec4 = (int4)5; + ivec4 = (int4)vec4_3; + + i = (int)ivec4; // expected-error {{invalid conversion between vector type 'int4' and integer type 'int' of different size}} + i = ivec4; // expected-error {{assigning to 'int' from incompatible type 'int4'}} + + ivec4 = (int4)ptr; // expected-error {{invalid conversion between vector type 'int4' and scalar type 'int *'}} + + vec4 = (float4)vec2; // expected-error {{invalid conversion between ext-vector type 'float4' and 'float2'}} + + ish8 += 5; // expected-error {{can't convert between vector values of different size ('short8' and 'int')}} + ish8 += (short)5; + ivec4 *= 5; + vec4 /= 5.2f; + vec4 %= 4; // expected-error {{invalid operands to binary expression ('float4' and 'int')}} + ivec4 %= 4; + ivec4 += vec4; // expected-error {{can't convert between vector values of different size ('int4' and 'float4')}} + ivec4 += (int4)vec4; + ivec4 -= ivec4; + ivec4 |= ivec4; + ivec4 += ptr; // expected-error {{can't convert between vector values of different size ('int4' and 'int *')}} +} + +typedef __attribute__(( ext_vector_type(2) )) float2 vecfloat2; // expected-error{{invalid vector element type 'float2'}} + +void inc(float2 f2) { + f2++; // expected-error{{cannot increment value of type 'float2'}} + __real f2; // expected-error{{invalid type 'float2' to __real operator}} +} diff --git a/clang/test/Sema/ext_vector_comparisons.c b/clang/test/Sema/ext_vector_comparisons.c new file mode 100644 index 0000000..605ba6c --- /dev/null +++ b/clang/test/Sema/ext_vector_comparisons.c @@ -0,0 +1,30 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wno-unreachable-code %s + +typedef __attribute__(( ext_vector_type(4) )) int int4; + +static int4 test1() { + int4 vec, rv; + + // comparisons to self... + return vec == vec; // expected-warning{{self-comparison always evaluates to a constant}} + return vec != vec; // expected-warning{{self-comparison always evaluates to a constant}} + return vec < vec; // expected-warning{{self-comparison always evaluates to a constant}} + return vec <= vec; // expected-warning{{self-comparison always evaluates to a constant}} + return vec > vec; // expected-warning{{self-comparison always evaluates to a constant}} + return vec >= vec; // expected-warning{{self-comparison always evaluates to a constant}} +} + + +typedef __attribute__(( ext_vector_type(4) )) float float4; + +static int4 test2() { + float4 vec, rv; + + // comparisons to self. no warning, they're floats + return vec == vec; // no-warning + return vec != vec; // no-warning + return vec < vec; // no-warning + return vec <= vec; // no-warning + return vec > vec; // no-warning + return vec >= vec; // no-warning +} diff --git a/clang/test/Sema/ext_vector_components.c b/clang/test/Sema/ext_vector_components.c new file mode 100644 index 0000000..7d3d52a --- /dev/null +++ b/clang/test/Sema/ext_vector_components.c @@ -0,0 +1,47 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +typedef __attribute__(( ext_vector_type(2) )) float float2; +typedef __attribute__(( ext_vector_type(3) )) float float3; +typedef __attribute__(( ext_vector_type(4) )) float float4; +typedef __attribute__(( ext_vector_type(16) )) float float16; + +static float4 vec4_0 = (float4)0.5f; + +static void test() { + float2 vec2, vec2_2; + float3 vec3; + float4 vec4, vec4_2, *vec4p; + float16 vec16; + float f; + + vec2.z; // expected-error {{vector component access exceeds type 'float2'}} + vec2.xyzw; // expected-error {{vector component access exceeds type 'float2'}} + vec4.xyzw; // expected-warning {{expression result unused}} + vec4.xyzc; // expected-error {{illegal vector component name 'c'}} + vec4.s01z; // expected-error {{illegal vector component name 'z'}} + vec2 = vec4.s01; // legal, shorten + vec2 = vec4.S01; // legal, shorten + + vec3 = vec4.xyz; // legal, shorten + f = vec2.x; // legal, shorten + f = vec4.xy.x; // legal, shorten + + vec4_2.xyzx = vec4.xyzw; // expected-error {{vector is not assignable (contains duplicate components)}} + vec4_2.xyzz = vec4.xyzw; // expected-error {{vector is not assignable (contains duplicate components)}} + vec4_2.xyyw = vec4.xyzw; // expected-error {{vector is not assignable (contains duplicate components)}} + vec2.x = f; + vec2.xx = vec2_2.xy; // expected-error {{vector is not assignable (contains duplicate components)}} + vec2.yx = vec2_2.xy; + vec4 = (float4){ 1,2,3,4 }; + vec4.xy.w; // expected-error {{vector component access exceeds type 'float2'}} + vec4.s06; // expected-error {{vector component access exceeds type 'float4'}} + vec4.x = vec16.sf; + vec4.x = vec16.sF; + + vec4p->yz = vec4p->xy; +} + +float2 lo(float3 x) { return x.lo; } +float2 hi(float3 x) { return x.hi; } +float2 ev(float3 x) { return x.even; } +float2 od(float3 x) { return x.odd; } diff --git a/clang/test/Sema/extern-redecl.c b/clang/test/Sema/extern-redecl.c new file mode 100644 index 0000000..c176725 --- /dev/null +++ b/clang/test/Sema/extern-redecl.c @@ -0,0 +1,22 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// rdar: // 8125274 +static int a16[]; // expected-warning {{tentative array definition assumed to have one element}} + +void f16(void) { + extern int a16[]; +} + + +// PR10013: Scope of extern declarations extend past enclosing block +extern int PR10013_x; +int PR10013(void) { + int *PR10013_x = 0; + { + extern int PR10013_x; + extern int PR10013_x; + } + + return PR10013_x; // expected-warning{{incompatible pointer to integer conversion}} +} + diff --git a/clang/test/Sema/flexible-array-init.c b/clang/test/Sema/flexible-array-init.c new file mode 100644 index 0000000..78fc7c5 --- /dev/null +++ b/clang/test/Sema/flexible-array-init.c @@ -0,0 +1,91 @@ +// RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s +struct one { + int a; + int values[]; // expected-note 4{{initialized flexible array member 'values' is here}} +} x = {5, {1, 2, 3}}; // expected-warning{{flexible array initialization is a GNU extension}} + +struct one x2 = { 5, 1, 2, 3 }; // expected-warning{{flexible array initialization is a GNU extension}} + +void test() { + struct one x3 = {5, {1, 2, 3}}; // expected-error{{initialization of flexible array member is not allowed}} + struct one x3a = { 5 }; + struct one x3b = { .a = 5 }; + struct one x3c = { 5, {} }; // expected-warning{{use of GNU empty initializer extension}} \ + // expected-warning{{flexible array initialization is a GNU extension}} \ + // expected-warning{{zero size arrays are an extension}} +} + +struct foo { + int x; + int y[]; // expected-note 8 {{initialized flexible array member 'y' is here}} +}; +struct bar { struct foo z; }; // expected-warning {{'z' may not be nested in a struct due to flexible array member}} + +struct foo a = { 1, { 2, 3, 4 } }; // expected-warning{{flexible array initialization is a GNU extension}} +struct bar b = { { 1, { 2, 3, 4 } } }; // expected-error{{initialization of flexible array member is not allowed}} +struct bar c = { { 1, { } } }; // // expected-warning{{flexible array initialization is a GNU extension}} \ + // expected-warning{{use of GNU empty initializer extension}} \ + // expected-warning{{zero size arrays are an extension}} +struct foo d[1] = { { 1, { 2, 3, 4 } } }; // expected-warning{{'struct foo' may not be used as an array element due to flexible array member}} \ + // expected-error{{initialization of flexible array member is not allowed}} + +struct foo desig_foo = { .y = {2, 3, 4} }; // expected-warning{{flexible array initialization is a GNU extension}} +struct bar desig_bar = { .z.y = { } }; // expected-warning{{use of GNU empty initializer extension}} \ + // expected-warning{{zero size arrays are an extension}} \ + // expected-warning{{flexible array initialization is a GNU extension}} +struct bar desig_bar2 = { .z.y = { 2, 3, 4} }; // expected-error{{initialization of flexible array member is not allowed}} +struct foo design_foo2 = { .y = 2 }; // expected-error{{flexible array requires brace-enclosed initializer}} + +struct point { + int x, y; +}; + +struct polygon { + int numpoints; + struct point points[]; // expected-note{{initialized flexible array member 'points' is here}} +}; +struct polygon poly = { + .points[2] = { 1, 2} }; // expected-error{{designator into flexible array member subobject}} + +// PR3540 +struct X { + int a; + int b; + char data[]; +}; + +struct Y { + int a:4; + int b:4; + int c; + int d; + int e; + struct X xs[]; // expected-warning{{'struct X' may not be used as an array element due to flexible array member}} +}; + + +// PR8217 +struct PR8217a { + int i; + char v[]; // expected-note 2 {{initialized flexible array member 'v' is here}} +}; + +void PR8217() { + struct PR8217a foo1 = { .i = 0, .v = "foo" }; // expected-error {{initialization of flexible array member is not allowed}} + struct PR8217a foo2 = { .i = 0 }; + struct PR8217a foo3 = { .i = 0, .v = { 'b', 'a', 'r', '\0' } }; // expected-error {{initialization of flexible array member is not allowed}} + struct PR8217a bar; +} + +typedef struct PR10648 { + unsigned long n; + int v[]; // expected-note {{initialized flexible array member 'v' is here}} +} PR10648; +int f10648() { + return (PR10648){2, {3, 4}}.v[1]; // expected-error {{initialization of flexible array member is not allowed}} +} + +struct FlexWithUnnamedBitfield { int : 10; int x; int y[]; }; // expected-note {{initialized flexible array member 'y' is here}} +void TestFlexWithUnnamedBitfield() { + struct FlexWithUnnamedBitfield x = {10, {3}}; // expected-error {{initialization of flexible array member is not allowed}} +} diff --git a/clang/test/Sema/floating-point-compare.c b/clang/test/Sema/floating-point-compare.c new file mode 100644 index 0000000..60f971c --- /dev/null +++ b/clang/test/Sema/floating-point-compare.c @@ -0,0 +1,25 @@ +// RUN: %clang_cc1 -fsyntax-only -Wfloat-equal -verify %s + +int f1(float x, float y) { + return x == y; // expected-warning {{comparing floating point with ==}} +} + +int f2(float x, float y) { + return x != y; // expected-warning {{comparing floating point with ==}} +} + +int f3(float x) { + return x == x; // no-warning +} + +int f4(float x) { + return x == 0.0; // no-warning {{comparing}} +} + +int f5(float x) { + return x == __builtin_inf(); // no-warning +} + +int f7(float x) { + return x == 3.14159; // expected-warning {{comparing}} +} diff --git a/clang/test/Sema/fn-ptr-as-fn-prototype.c b/clang/test/Sema/fn-ptr-as-fn-prototype.c new file mode 100644 index 0000000..cf95c97 --- /dev/null +++ b/clang/test/Sema/fn-ptr-as-fn-prototype.c @@ -0,0 +1,15 @@ +// RUN: %clang_cc1_only -ast-print %s | FileCheck %s + +// This testcase checks the functionality of +// Sema::ActOn{Start,End}FunctionDeclarator, specifically checking that +// ActOnEndFunctionDeclarator is called after the typedef so the enum +// is in the global scope, not the scope of f(). + +// CHECK: typedef void (*g)(); +typedef void (*g) (); +// CHECK: enum { +enum { + k = -1 +}; +// CHECK: void f() { +void f() {} diff --git a/clang/test/Sema/for.c b/clang/test/Sema/for.c new file mode 100644 index 0000000..b998f4b --- /dev/null +++ b/clang/test/Sema/for.c @@ -0,0 +1,7 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// Check C99 6.8.5p3 +void b1 (void) { for (void (*f) (void);;); } +void b2 (void) { for (void f (void);;); } // expected-error {{declaration of non-local variable}} +void b3 (void) { for (static int f;;); } // expected-error {{declaration of non-local variable}} +void b4 (void) { for (typedef int f;;); } // expected-error {{declaration of non-local variable}} diff --git a/clang/test/Sema/format-string-percentm.c b/clang/test/Sema/format-string-percentm.c new file mode 100644 index 0000000..1ffc439 --- /dev/null +++ b/clang/test/Sema/format-string-percentm.c @@ -0,0 +1,7 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -triple i686-pc-linux-gnu + +// PR 4142 - support glibc extension to printf: '%m' (which prints strerror(errno)). +int printf(char const*,...); +void percentm(void) { + printf("%m"); +} diff --git a/clang/test/Sema/format-strings-c90.c b/clang/test/Sema/format-strings-c90.c new file mode 100644 index 0000000..66ca507 --- /dev/null +++ b/clang/test/Sema/format-strings-c90.c @@ -0,0 +1,30 @@ +/* RUN: %clang_cc1 -fsyntax-only -verify -triple i386-apple-darwin9 -pedantic -std=c89 %s + */ + +int scanf(const char * restrict, ...); +int printf(const char *restrict, ...); + +void foo(char **sp, float *fp, int *ip) { + scanf("%as", sp); /* expected-warning{{'a' length modifier is not supported by ISO C}} */ + scanf("%a[abc]", sp); /* expected-warning{{'a' length modifier is not supported by ISO C}} */ + + /* TODO: Warn that the 'a' conversion specifier is a C99 feature. */ + scanf("%a", fp); + scanf("%afoobar", fp); + printf("%a", 1.0); + printf("%as", 1.0); + printf("%aS", 1.0); + printf("%a[", 1.0); + printf("%afoo", 1.0); + + scanf("%da", ip); + + /* Test argument type check for the 'a' length modifier. */ + scanf("%as", fp); /* expected-warning{{format specifies type 'char **' but the argument has type 'float *'}} + expected-warning{{'a' length modifier is not supported by ISO C}} */ + scanf("%aS", fp); /* expected-warning{{format specifies type 'wchar_t **' (aka 'int **') but the argument has type 'float *'}} + expected-warning{{'a' length modifier is not supported by ISO C}} + expected-warning{{'S' conversion specifier is not supported by ISO C}} */ + scanf("%a[abc]", fp); /* expected-warning{{format specifies type 'char **' but the argument has type 'float *'}} + expected-warning{{'a' length modifier is not supported by ISO C}} */ +} diff --git a/clang/test/Sema/format-strings-fixit-ssize_t.c b/clang/test/Sema/format-strings-fixit-ssize_t.c new file mode 100644 index 0000000..5208a29 --- /dev/null +++ b/clang/test/Sema/format-strings-fixit-ssize_t.c @@ -0,0 +1,18 @@ +// RUN: cp %s %t +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -pedantic -Wall -fixit %t +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -pedantic -Wall -Werror %t +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -E -o - %t | FileCheck %s + +/* This is a test of the various code modification hints that are + provided as part of warning or extension diagnostics. All of the + warnings will be fixed by -fixit, and the resulting file should + compile cleanly with -Werror -pedantic. */ + +int printf(char const *, ...); + +void test() { + typedef signed long int ssize_t; + printf("%f", (ssize_t) 42); +} + +// CHECK: printf("%zd", (ssize_t) 42); diff --git a/clang/test/Sema/format-strings-fixit.c b/clang/test/Sema/format-strings-fixit.c new file mode 100644 index 0000000..800691e --- /dev/null +++ b/clang/test/Sema/format-strings-fixit.c @@ -0,0 +1,208 @@ +// RUN: cp %s %t +// RUN: %clang_cc1 -pedantic -Wall -fixit %t +// RUN: %clang_cc1 -fsyntax-only -pedantic -Wall -Werror %t +// RUN: %clang_cc1 -E -o - %t | FileCheck %s + +/* This is a test of the various code modification hints that are + provided as part of warning or extension diagnostics. All of the + warnings will be fixed by -fixit, and the resulting file should + compile cleanly with -Werror -pedantic. */ + +int printf(char const *, ...); + +typedef __SIZE_TYPE__ size_t; +typedef __INTMAX_TYPE__ intmax_t; +typedef __UINTMAX_TYPE__ uintmax_t; +typedef __PTRDIFF_TYPE__ ptrdiff_t; + +void test() { + // Basic types + printf("%s", (int) 123); + printf("abc%0f", "testing testing 123"); + printf("%u", (long) -12); + printf("%p", 123); + printf("%c\n", "x"); + printf("%c\n", 1.23); + + // Larger types + printf("%+.2d", (unsigned long long) 123456); + printf("%1d", (long double) 1.23); + + // Flag handling + printf("%0+s", (unsigned) 31337); // 0 flag should stay + printf("%#p", (void *) 0); + printf("% +f", 1.23); // + flag should stay + printf("%0-f", 1.23); // - flag should stay + + // Positional arguments +#pragma clang diagnostic push // Don't warn about using positional arguments. +#pragma clang diagnostic ignored "-Wformat-non-iso" + printf("%1$f:%2$.*3$f:%4$.*3$f\n", 1, 2, 3, 4); +#pragma clang diagnostic pop + + // Precision + printf("%10.5d", 1l); // (bug 7394) + printf("%.2c", 'a'); + + // Ignored flags + printf("%0-f", 1.23); + + // Bad length modifiers + printf("%hhs", "foo"); +#pragma clang diagnostic push // Don't warn about using positional arguments. +#pragma clang diagnostic ignored "-Wformat-non-iso" + printf("%1$zp", (void *)0); +#pragma clang diagnostic pop + + // Preserve the original formatting for unsigned integers. + unsigned long val = 42; + printf("%X", val); + + // size_t, etc. + printf("%f", (size_t) 42); + printf("%f", (intmax_t) 42); + printf("%f", (uintmax_t) 42); + printf("%f", (ptrdiff_t) 42); + + // string + printf("%ld", "foo"); + + // Preserve the original choice of conversion specifier. + printf("%o", (long) 42); + printf("%u", (long) 42); + printf("%x", (long) 42); + printf("%X", (long) 42); + printf("%i", (unsigned long) 42); + printf("%d", (unsigned long) 42); + printf("%F", (long double) 42); + printf("%e", (long double) 42); + printf("%E", (long double) 42); + printf("%g", (long double) 42); + printf("%G", (long double) 42); + printf("%a", (long double) 42); + printf("%A", (long double) 42); +} + +int scanf(char const *, ...); + +void test2() { + char str[100]; + short shortVar; + unsigned short uShortVar; + int intVar; + unsigned uIntVar; + float floatVar; + double doubleVar; + long double longDoubleVar; + long longVar; + unsigned long uLongVar; + long long longLongVar; + unsigned long long uLongLongVar; + size_t sizeVar; + intmax_t intmaxVar; + uintmax_t uIntmaxVar; + ptrdiff_t ptrdiffVar; + + scanf("%lf", str); + scanf("%f", &shortVar); + scanf("%f", &uShortVar); + scanf("%p", &intVar); + scanf("%Lf", &uIntVar); + scanf("%ld", &floatVar); + scanf("%f", &doubleVar); + scanf("%d", &longDoubleVar); + scanf("%f", &longVar); + scanf("%f", &uLongVar); + scanf("%f", &longLongVar); + scanf("%f", &uLongLongVar); + + // Some named ints. + scanf("%f", &sizeVar); + scanf("%f", &intmaxVar); + scanf("%f", &uIntmaxVar); + scanf("%f", &ptrdiffVar); + + // Preserve the original formatting. + scanf("%o", &longVar); + scanf("%u", &longVar); + scanf("%x", &longVar); + scanf("%X", &longVar); + scanf("%i", &uLongVar); + scanf("%d", &uLongVar); + scanf("%F", &longDoubleVar); + scanf("%e", &longDoubleVar); + scanf("%E", &longDoubleVar); + scanf("%g", &longDoubleVar); + scanf("%G", &longDoubleVar); + scanf("%a", &longDoubleVar); + scanf("%A", &longDoubleVar); +} + +// Validate the fixes. +// CHECK: printf("%d", (int) 123); +// CHECK: printf("abc%s", "testing testing 123"); +// CHECK: printf("%lu", (long) -12); +// CHECK: printf("%d", 123); +// CHECK: printf("%s\n", "x"); +// CHECK: printf("%f\n", 1.23); +// CHECK: printf("%+.2lld", (unsigned long long) 123456); +// CHECK: printf("%1Lf", (long double) 1.23); +// CHECK: printf("%0u", (unsigned) 31337); +// CHECK: printf("%p", (void *) 0); +// CHECK: printf("%+f", 1.23); +// CHECK: printf("%-f", 1.23); +// CHECK: printf("%1$d:%2$.*3$d:%4$.*3$d\n", 1, 2, 3, 4); +// CHECK: printf("%10.5ld", 1l); +// CHECK: printf("%c", 'a'); +// CHECK: printf("%-f", 1.23); +// CHECK: printf("%s", "foo"); +// CHECK: printf("%1$p", (void *)0); +// CHECK: printf("%lX", val); +// CHECK: printf("%zu", (size_t) 42); +// CHECK: printf("%jd", (intmax_t) 42); +// CHECK: printf("%ju", (uintmax_t) 42); +// CHECK: printf("%td", (ptrdiff_t) 42); +// CHECK: printf("%s", "foo"); +// CHECK: printf("%lo", (long) 42); +// CHECK: printf("%lu", (long) 42); +// CHECK: printf("%lx", (long) 42); +// CHECK: printf("%lX", (long) 42); +// CHECK: printf("%li", (unsigned long) 42); +// CHECK: printf("%ld", (unsigned long) 42); +// CHECK: printf("%LF", (long double) 42); +// CHECK: printf("%Le", (long double) 42); +// CHECK: printf("%LE", (long double) 42); +// CHECK: printf("%Lg", (long double) 42); +// CHECK: printf("%LG", (long double) 42); +// CHECK: printf("%La", (long double) 42); +// CHECK: printf("%LA", (long double) 42); + +// CHECK: scanf("%s", str); +// CHECK: scanf("%hd", &shortVar); +// CHECK: scanf("%hu", &uShortVar); +// CHECK: scanf("%d", &intVar); +// CHECK: scanf("%u", &uIntVar); +// CHECK: scanf("%f", &floatVar); +// CHECK: scanf("%lf", &doubleVar); +// CHECK: scanf("%Lf", &longDoubleVar); +// CHECK: scanf("%ld", &longVar); +// CHECK: scanf("%lu", &uLongVar); +// CHECK: scanf("%lld", &longLongVar); +// CHECK: scanf("%llu", &uLongLongVar); +// CHECK: scanf("%zu", &sizeVar); +// CHECK: scanf("%jd", &intmaxVar); +// CHECK: scanf("%ju", &uIntmaxVar); +// CHECK: scanf("%td", &ptrdiffVar); +// CHECK: scanf("%lo", &longVar); +// CHECK: scanf("%lu", &longVar); +// CHECK: scanf("%lx", &longVar); +// CHECK: scanf("%lX", &longVar); +// CHECK: scanf("%li", &uLongVar); +// CHECK: scanf("%ld", &uLongVar); +// CHECK: scanf("%LF", &longDoubleVar); +// CHECK: scanf("%Le", &longDoubleVar); +// CHECK: scanf("%LE", &longDoubleVar); +// CHECK: scanf("%Lg", &longDoubleVar); +// CHECK: scanf("%LG", &longDoubleVar); +// CHECK: scanf("%La", &longDoubleVar); +// CHECK: scanf("%LA", &longDoubleVar); diff --git a/clang/test/Sema/format-strings-int-typedefs.c b/clang/test/Sema/format-strings-int-typedefs.c new file mode 100644 index 0000000..341d49c --- /dev/null +++ b/clang/test/Sema/format-strings-int-typedefs.c @@ -0,0 +1,37 @@ +// RUN: %clang_cc1 -triple i386-apple-darwin9 -fsyntax-only -verify %s + +int printf(char const *, ...); +int scanf(char const *, ...); + +void test(void) { + printf("%jd", 42.0); // expected-warning {{format specifies type 'intmax_t' (aka 'long long')}} + printf("%ju", 42.0); // expected-warning {{format specifies type 'uintmax_t' (aka 'unsigned long long')}} + printf("%zu", 42.0); // expected-warning {{format specifies type 'size_t' (aka 'unsigned long')}} + printf("%td", 42.0); // expected-warning {{format specifies type 'ptrdiff_t' (aka 'int')}} + printf("%lc", 42.0); // expected-warning {{format specifies type 'wint_t' (aka 'int')}} + printf("%ls", 42.0); // expected-warning {{format specifies type 'wchar_t *' (aka 'int *')}} + printf("%S", 42.0); // expected-warning {{format specifies type 'wchar_t *' (aka 'int *')}} + printf("%C", 42.0); // expected-warning {{format specifies type 'wchar_t' (aka 'int')}} + + scanf("%jd", 0); // expected-warning {{format specifies type 'intmax_t *' (aka 'long long *')}} + scanf("%ju", 0); // expected-warning {{format specifies type 'uintmax_t *' (aka 'unsigned long long *')}} + scanf("%zu", 0); // expected-warning {{format specifies type 'size_t *' (aka 'unsigned long *')}} + scanf("%td", 0); // expected-warning {{format specifies type 'ptrdiff_t *' (aka 'int *')}} + scanf("%lc", 0); // expected-warning {{format specifies type 'wchar_t *' (aka 'int *')}} + scanf("%ls", 0); // expected-warning {{format specifies type 'wchar_t *' (aka 'int *')}} + scanf("%S", 0); // expected-warning {{format specifies type 'wchar_t *' (aka 'int *')}} + scanf("%C", 0); // expected-warning {{format specifies type 'wchar_t *' (aka 'int *')}} + + + // typedef size_t et al. to something crazy. + typedef void *size_t; + typedef void *intmax_t; + typedef void *uintmax_t; + typedef void *ptrdiff_t; + + // The warning still fires, because it checks the underlying type. + printf("%jd", (intmax_t)42); // expected-warning {{format specifies type 'intmax_t' (aka 'long long') but the argument has type 'intmax_t' (aka 'void *')}} + printf("%ju", (uintmax_t)42); // expected-warning {{format specifies type 'uintmax_t' (aka 'unsigned long long') but the argument has type 'uintmax_t' (aka 'void *')}} + printf("%zu", (size_t)42); // expected-warning {{format specifies type 'size_t' (aka 'unsigned long') but the argument has type 'size_t' (aka 'void *')}} + printf("%td", (ptrdiff_t)42); // expected-warning {{format specifies type 'ptrdiff_t' (aka 'int') but the argument has type 'ptrdiff_t' (aka 'void *')}} +} diff --git a/clang/test/Sema/format-strings-no-fixit.c b/clang/test/Sema/format-strings-no-fixit.c new file mode 100644 index 0000000..701e945 --- /dev/null +++ b/clang/test/Sema/format-strings-no-fixit.c @@ -0,0 +1,65 @@ +// RUN: cp %s %t +// RUN: %clang_cc1 -fsyntax-only -fixit %t +// RUN: %clang_cc1 -E -o - %t | FileCheck %s + +/* This is a test of the various code modification hints that are + provided as part of warning or extension diagnostics. Only + warnings for format strings within the function call will be + fixed by -fixit. Other format strings will be left alone. */ + +int printf(char const *, ...); +int scanf(char const *, ...); + +void pr9751() { + const char kFormat1[] = "%s"; + printf(kFormat1, 5); + printf("%s", 5); + + const char kFormat2[] = "%.3p"; + void *p; + printf(kFormat2, p); + printf("%.3p", p); + + const char kFormat3[] = "%0s"; + printf(kFormat3, "a"); + printf("%0s", "a"); + + const char kFormat4[] = "%hhs"; + printf(kFormat4, "a"); + printf("%hhs", "a"); + + const char kFormat5[] = "%-0d"; + printf(kFormat5, 5); + printf("%-0d", 5); + + const char kFormat6[] = "%00d"; + int *i; + scanf(kFormat6, i); + scanf("%00d", i); +} + +// CHECK: const char kFormat1[] = "%s"; +// CHECK: printf(kFormat1, 5); +// CHECK: printf("%d", 5); + +// CHECK: const char kFormat2[] = "%.3p"; +// CHECK: void *p; +// CHECK: printf(kFormat2, p); +// CHECK: printf("%p", p); + +// CHECK: const char kFormat3[] = "%0s"; +// CHECK: printf(kFormat3, "a"); +// CHECK: printf("%s", "a"); + +// CHECK: const char kFormat4[] = "%hhs"; +// CHECK: printf(kFormat4, "a"); +// CHECK: printf("%s", "a"); + +// CHECK: const char kFormat5[] = "%-0d"; +// CHECK: printf(kFormat5, 5); +// CHECK: printf("%-d", 5); + +// CHECK: const char kFormat6[] = "%00d"; +// CHECK: int *i; +// CHECK: scanf(kFormat6, i); +// CHECK: scanf("%d", i); diff --git a/clang/test/Sema/format-strings-non-iso.c b/clang/test/Sema/format-strings-non-iso.c new file mode 100644 index 0000000..ed8095f --- /dev/null +++ b/clang/test/Sema/format-strings-non-iso.c @@ -0,0 +1,29 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c99 -pedantic %s + +int printf(const char *restrict, ...); +int scanf(const char * restrict, ...); + +void f(void) { + char *cp; + + // The 'q' length modifier. + printf("%qd", (long long)42); // expected-warning{{'q' length modifier is not supported by ISO C}} + scanf("%qd", (long long *)0); // expected-warning{{'q' length modifier is not supported by ISO C}} + + // The 'm' length modifier. + scanf("%ms", &cp); // expected-warning{{'m' length modifier is not supported by ISO C}} + + // The 'S' and 'C' conversion specifiers. + printf("%S", L"foo"); // expected-warning{{'S' conversion specifier is not supported by ISO C}} + printf("%C", L'x'); // expected-warning{{'C' conversion specifier is not supported by ISO C}} + + // Combining 'L' with an integer conversion specifier. + printf("%Li", (long long)42); // expected-warning{{using length modifier 'L' with conversion specifier 'i' is not supported by ISO C}} + printf("%Lo", (long long)42); // expected-warning{{using length modifier 'L' with conversion specifier 'o' is not supported by ISO C}} + printf("%Lu", (long long)42); // expected-warning{{using length modifier 'L' with conversion specifier 'u' is not supported by ISO C}} + printf("%Lx", (long long)42); // expected-warning{{using length modifier 'L' with conversion specifier 'x' is not supported by ISO C}} + printf("%LX", (long long)42); // expected-warning{{using length modifier 'L' with conversion specifier 'X' is not supported by ISO C}} + + // Positional arguments. + printf("%1$d", 42); // expected-warning{{positional arguments are not supported by ISO C}} +} diff --git a/clang/test/Sema/format-strings-scanf.c b/clang/test/Sema/format-strings-scanf.c new file mode 100644 index 0000000..e94af5a --- /dev/null +++ b/clang/test/Sema/format-strings-scanf.c @@ -0,0 +1,123 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -triple i386-apple-darwin9 -Wformat-nonliteral %s + +// Test that -Wformat=0 works: +// RUN: %clang_cc1 -fsyntax-only -Werror -Wformat=0 %s + +#include <stdarg.h> +typedef __typeof(sizeof(int)) size_t; +typedef struct _FILE FILE; +typedef __WCHAR_TYPE__ wchar_t; + +int fscanf(FILE * restrict, const char * restrict, ...) ; +int scanf(const char * restrict, ...) ; +int sscanf(const char * restrict, const char * restrict, ...) ; +int my_scanf(const char * restrict, ...) __attribute__((__format__(__scanf__, 1, 2))); + +int vscanf(const char * restrict, va_list); +int vfscanf(FILE * restrict, const char * restrict, va_list); +int vsscanf(const char * restrict, const char * restrict, va_list); + +void test(const char *s, int *i) { + scanf(s, i); // expected-warning{{ormat string is not a string literal}} + scanf("%0d", i); // expected-warning{{zero field width in scanf format string is unused}} + scanf("%00d", i); // expected-warning{{zero field width in scanf format string is unused}} + scanf("%d%[asdfasdfd", i, s); // expected-warning{{no closing ']' for '%[' in scanf format string}} + + unsigned short s_x; + scanf ("%" "hu" "\n", &s_x); // no-warning + scanf("%y", i); // expected-warning{{invalid conversion specifier 'y'}} + scanf("%%"); // no-warning + scanf("%%%1$d", i); // no-warning + scanf("%1$d%%", i); // no-warning + scanf("%d", i, i); // expected-warning{{data argument not used by format string}} + scanf("%*d", i); // // expected-warning{{data argument not used by format string}} + scanf("%*d", i); // // expected-warning{{data argument not used by format string}} + scanf("%*d%1$d", i); // no-warning +} + +void bad_length_modifiers(char *s, void *p, wchar_t *ws, long double *ld) { + scanf("%hhs", "foo"); // expected-warning{{length modifier 'hh' results in undefined behavior or no effect with 's' conversion specifier}} + scanf("%1$zp", &p); // expected-warning{{length modifier 'z' results in undefined behavior or no effect with 'p' conversion specifier}} + scanf("%ls", ws); // no-warning + scanf("%#.2Lf", ld); // expected-warning{{invalid conversion specifier '#'}} +} + +// Test that the scanf call site is where the warning is attached. If the +// format string is somewhere else, point to it in a note. +void pr9751() { + int *i; + char str[100]; + const char kFormat1[] = "%00d"; // expected-note{{format string is defined here}}} + scanf(kFormat1, i); // expected-warning{{zero field width in scanf format string is unused}} + scanf("%00d", i); // expected-warning{{zero field width in scanf format string is unused}} + const char kFormat2[] = "%["; // expected-note{{format string is defined here}}} + scanf(kFormat2, str); // expected-warning{{no closing ']' for '%[' in scanf format string}} + scanf("%[", str); // expected-warning{{no closing ']' for '%[' in scanf format string}} + const char kFormat3[] = "%hu"; // expected-note{{format string is defined here}}} + scanf(kFormat3, &i); // expected-warning {{format specifies type 'unsigned short *' but the argument}} + const char kFormat4[] = "%lp"; // expected-note{{format string is defined here}}} + scanf(kFormat4, &i); // expected-warning {{length modifier 'l' results in undefined behavior or no effect with 'p' conversion specifier}} +} + +void test_variants(int *i, const char *s, ...) { + FILE *f = 0; + char buf[100]; + + fscanf(f, "%ld", i); // expected-warning{{format specifies type 'long *' but the argument has type 'int *'}} + sscanf(buf, "%ld", i); // expected-warning{{format specifies type 'long *' but the argument has type 'int *'}} + my_scanf("%ld", i); // expected-warning{{format specifies type 'long *' but the argument has type 'int *'}} + + va_list ap; + va_start(ap, s); + + vscanf("%[abc", ap); // expected-warning{{no closing ']' for '%[' in scanf format string}} + vfscanf(f, "%[abc", ap); // expected-warning{{no closing ']' for '%[' in scanf format string}} + vsscanf(buf, "%[abc", ap); // expected-warning{{no closing ']' for '%[' in scanf format string}} +} + +void test_scanlist(int *ip, char *sp, wchar_t *ls) { + scanf("%[abc]", ip); // expected-warning{{format specifies type 'char *' but the argument has type 'int *'}} + scanf("%h[abc]", sp); // expected-warning{{length modifier 'h' results in undefined behavior or no effect with '[' conversion specifier}} + scanf("%l[xyx]", ls); // no-warning + scanf("%ll[xyx]", ls); // expected-warning {{length modifier 'll' results in undefined behavior or no effect with '[' conversion specifier}} +} + +void test_alloc_extension(char **sp, wchar_t **lsp, float *fp) { + /* Make sure "%a" gets parsed as a conversion specifier for float, + * even when followed by an 's', 'S' or '[', which would cause it to be + * parsed as a length modifier in C90. */ + scanf("%as", sp); // expected-warning{{format specifies type 'float *' but the argument has type 'char **'}} + scanf("%aS", lsp); // expected-warning{{format specifies type 'float *' but the argument has type 'wchar_t **'}} + scanf("%a[bcd]", sp); // expected-warning{{format specifies type 'float *' but the argument has type 'char **'}} + + // Test that the 'm' length modifier is only allowed with s, S, c, C or [. + // TODO: Warn that 'm' is an extension. + scanf("%ms", sp); // No warning. + scanf("%mS", lsp); // No warning. + scanf("%mc", sp); // No warning. + scanf("%mC", lsp); // No warning. + scanf("%m[abc]", sp); // No warning. + scanf("%md", sp); // expected-warning{{length modifier 'm' results in undefined behavior or no effect with 'd' conversion specifier}} + + // Test argument type check for the 'm' length modifier. + scanf("%ms", fp); // expected-warning{{format specifies type 'char **' but the argument has type 'float *'}} + scanf("%mS", fp); // expected-warning{{format specifies type 'wchar_t **' (aka 'int **') but the argument has type 'float *'}} + scanf("%mc", fp); // expected-warning{{format specifies type 'char **' but the argument has type 'float *'}} + scanf("%mC", fp); // expected-warning{{format specifies type 'wchar_t **' (aka 'int **') but the argument has type 'float *'}} + scanf("%m[abc]", fp); // expected-warning{{format specifies type 'char **' but the argument has type 'float *'}} +} + +void test_longlong(long long *x, unsigned long long *y) { + scanf("%Ld", y); // no-warning + scanf("%Lu", y); // no-warning + scanf("%Lx", y); // no-warning + scanf("%Ld", x); // no-warning + scanf("%Lu", x); // no-warning + scanf("%Lx", x); // no-warning + scanf("%Ls", "hello"); // expected-warning {{length modifier 'L' results in undefined behavior or no effect with 's' conversion specifier}} +} + +void test_quad(int *x, long long *llx) { + scanf("%qd", x); // expected-warning{{format specifies type 'long long *' but the argument has type 'int *'}} + scanf("%qd", llx); // no-warning +} diff --git a/clang/test/Sema/format-strings-size_t.c b/clang/test/Sema/format-strings-size_t.c new file mode 100644 index 0000000..7f88ff3 --- /dev/null +++ b/clang/test/Sema/format-strings-size_t.c @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify %s + +int printf(char const *, ...); + +void test(void) { + // size_t + printf("%zu", (double)42); // expected-warning {{format specifies type 'size_t' (aka 'unsigned long') but the argument has type 'double'}} + + // intmax_t / uintmax_t + printf("%jd", (double)42); // expected-warning {{format specifies type 'intmax_t' (aka 'long') but the argument has type 'double'}} + printf("%ju", (double)42); // expected-warning {{format specifies type 'uintmax_t' (aka 'unsigned long') but the argument has type 'double'}} + + // ptrdiff_t + printf("%td", (double)42); // expected-warning {{format specifies type 'ptrdiff_t' (aka 'long') but the argument has type 'double'}} +} diff --git a/clang/test/Sema/format-strings.c b/clang/test/Sema/format-strings.c new file mode 100644 index 0000000..086c5c6 --- /dev/null +++ b/clang/test/Sema/format-strings.c @@ -0,0 +1,523 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wformat-nonliteral %s + +#include <stdarg.h> +typedef __typeof(sizeof(int)) size_t; +typedef struct _FILE FILE; +int fprintf(FILE *, const char *restrict, ...); +int printf(const char *restrict, ...); // expected-note{{passing argument to parameter here}} +int snprintf(char *restrict, size_t, const char *restrict, ...); +int sprintf(char *restrict, const char *restrict, ...); +int vasprintf(char **, const char *, va_list); +int asprintf(char **, const char *, ...); +int vfprintf(FILE *, const char *restrict, va_list); +int vprintf(const char *restrict, va_list); +int vsnprintf(char *, size_t, const char *, va_list); +int vsprintf(char *restrict, const char *restrict, va_list); // expected-note{{passing argument to parameter here}} + +int vscanf(const char *restrict format, va_list arg); + +char * global_fmt; + +void check_string_literal( FILE* fp, const char* s, char *buf, ... ) { + + char * b; + va_list ap; + va_start(ap,buf); + + printf(s); // expected-warning {{format string is not a string literal}} + vprintf(s,ap); // expected-warning {{format string is not a string literal}} + fprintf(fp,s); // expected-warning {{format string is not a string literal}} + vfprintf(fp,s,ap); // expected-warning {{format string is not a string literal}} + asprintf(&b,s); // expected-warning {{format string is not a string lit}} + vasprintf(&b,s,ap); // expected-warning {{format string is not a string literal}} + sprintf(buf,s); // expected-warning {{format string is not a string literal}} + snprintf(buf,2,s); // expected-warning {{format string is not a string lit}} + __builtin___sprintf_chk(buf,0,-1,s); // expected-warning {{format string is not a string literal}} + __builtin___snprintf_chk(buf,2,0,-1,s); // expected-warning {{format string is not a string lit}} + vsprintf(buf,s,ap); // expected-warning {{format string is not a string lit}} + vsnprintf(buf,2,s,ap); // expected-warning {{format string is not a string lit}} + vsnprintf(buf,2,global_fmt,ap); // expected-warning {{format string is not a string literal}} + __builtin___vsnprintf_chk(buf,2,0,-1,s,ap); // expected-warning {{format string is not a string lit}} + __builtin___vsnprintf_chk(buf,2,0,-1,global_fmt,ap); // expected-warning {{format string is not a string literal}} + + vscanf(s, ap); // expected-warning {{format string is not a string literal}} + + // rdar://6079877 + printf("abc" + "%*d", 1, 1); // no-warning + printf("abc\ +def" + "%*d", 1, 1); // no-warning + + // <rdar://problem/6079850>, allow 'unsigned' (instead of 'int') to be used for both + // the field width and precision. This deviates from C99, but is reasonably safe + // and is also accepted by GCC. + printf("%*d", (unsigned) 1, 1); // no-warning +} + +__attribute__((__format__ (__printf__, 2, 4))) +void check_string_literal2( FILE* fp, const char* s, char *buf, ... ) { + char * b; + va_list ap; + va_start(ap,buf); + + printf(s); // expected-warning {{format string is not a string literal}} + vprintf(s,ap); // no-warning + fprintf(fp,s); // expected-warning {{format string is not a string literal}} + vfprintf(fp,s,ap); // no-warning + asprintf(&b,s); // expected-warning {{format string is not a string lit}} + vasprintf(&b,s,ap); // no-warning + sprintf(buf,s); // expected-warning {{format string is not a string literal}} + snprintf(buf,2,s); // expected-warning {{format string is not a string lit}} + __builtin___vsnprintf_chk(buf,2,0,-1,s,ap); // no-warning + + vscanf(s, ap); // expected-warning {{format string is not a string literal}} +} + +void check_conditional_literal(const char* s, int i) { + printf(i == 1 ? "yes" : "no"); // no-warning + printf(i == 0 ? (i == 1 ? "yes" : "no") : "dont know"); // no-warning + printf(i == 0 ? (i == 1 ? s : "no") : "dont know"); // expected-warning{{format string is not a string literal}} + printf("yes" ?: "no %d", 1); // expected-warning{{data argument not used by format string}} +} + +void check_writeback_specifier() +{ + int x; + char *b; + + printf("%n",&x); // expected-warning {{'%n' in format string discouraged}} + sprintf(b,"%d%%%n",1, &x); // expected-warning {{'%n' in format string dis}} +} + +void check_invalid_specifier(FILE* fp, char *buf) +{ + printf("%s%lb%d","unix",10,20); // expected-warning {{invalid conversion specifier 'b'}} + fprintf(fp,"%%%l"); // expected-warning {{incomplete format specifier}} + sprintf(buf,"%%%%%ld%d%d", 1, 2, 3); // expected-warning{{format specifies type 'long' but the argument has type 'int'}} + snprintf(buf, 2, "%%%%%ld%;%d", 1, 2, 3); // expected-warning{{format specifies type 'long' but the argument has type 'int'}} expected-warning {{invalid conversion specifier ';'}} +} + +void check_null_char_string(char* b) +{ + printf("\0this is bogus%d",1); // expected-warning {{string contains '\0'}} + snprintf(b,10,"%%%%%d\0%d",1,2); // expected-warning {{string contains '\0'}} + printf("%\0d",1); // expected-warning {{string contains '\0'}} +} + +void check_empty_format_string(char* buf, ...) +{ + va_list ap; + va_start(ap,buf); + vprintf("",ap); // expected-warning {{format string is empty}} + sprintf(buf, "", 1); // expected-warning {{format string is empty}} + + // Don't warn about empty format strings when there are no data arguments. + // This can arise from macro expansions and non-standard format string + // functions. + sprintf(buf, ""); // no-warning +} + +void check_wide_string(char* b, ...) +{ + va_list ap; + va_start(ap,b); + + printf(L"foo %d",2); // expected-warning {{incompatible pointer types}}, expected-warning {{should not be a wide string}} + vsprintf(b,L"bar %d",ap); // expected-warning {{incompatible pointer types}}, expected-warning {{should not be a wide string}} +} + +void check_asterisk_precision_width(int x) { + printf("%*d"); // expected-warning {{'*' specified field width is missing a matching 'int' argument}} + printf("%.*d"); // expected-warning {{'.*' specified field precision is missing a matching 'int' argument}} + printf("%*d",12,x); // no-warning + printf("%*d","foo",x); // expected-warning {{field width should have type 'int', but argument has type 'char *'}} + printf("%.*d","foo",x); // expected-warning {{field precision should have type 'int', but argument has type 'char *'}} +} + +void __attribute__((format(printf,1,3))) myprintf(const char*, int blah, ...); + +void test_myprintf() { + myprintf("%d", 17, 18); // okay +} + +void test_constant_bindings(void) { + const char * const s1 = "hello"; + const char s2[] = "hello"; + const char *s3 = "hello"; + char * const s4 = "hello"; + extern const char s5[]; + + printf(s1); // no-warning + printf(s2); // no-warning + printf(s3); // expected-warning{{not a string literal}} + printf(s4); // expected-warning{{not a string literal}} + printf(s5); // expected-warning{{not a string literal}} +} + + +// Test what happens when -Wformat-security only. +#pragma GCC diagnostic ignored "-Wformat-nonliteral" +#pragma GCC diagnostic warning "-Wformat-security" + +void test9(char *P) { + int x; + printf(P); // expected-warning {{format string is not a string literal (potentially insecure)}} + printf(P, 42); + printf("%n", &x); // expected-warning {{use of '%n' in format string discouraged }} +} + +void torture(va_list v8) { + vprintf ("%*.*d", v8); // no-warning + +} + +void test10(int x, float f, int i, long long lli) { + printf("%s"); // expected-warning{{more '%' conversions than data arguments}} + printf("%@", 12); // expected-warning{{invalid conversion specifier '@'}} + printf("\0"); // expected-warning{{format string contains '\0' within the string body}} + printf("xs\0"); // expected-warning{{format string contains '\0' within the string body}} + printf("%*d\n"); // expected-warning{{'*' specified field width is missing a matching 'int' argument}} + printf("%*.*d\n", x); // expected-warning{{'.*' specified field precision is missing a matching 'int' argument}} + printf("%*d\n", f, x); // expected-warning{{field width should have type 'int', but argument has type 'double'}} + printf("%*.*d\n", x, f, x); // expected-warning{{field precision should have type 'int', but argument has type 'double'}} + printf("%**\n"); // expected-warning{{invalid conversion specifier '*'}} + printf("%n", &i); // expected-warning{{use of '%n' in format string discouraged (potentially insecure)}} + printf("%d%d\n", x); // expected-warning{{more '%' conversions than data arguments}} + printf("%d\n", x, x); // expected-warning{{data argument not used by format string}} + printf("%W%d%Z\n", x, x, x); // expected-warning{{invalid conversion specifier 'W'}} expected-warning{{invalid conversion specifier 'Z'}} + printf("%"); // expected-warning{{incomplete format specifier}} + printf("%.d", x); // no-warning + printf("%.", x); // expected-warning{{incomplete format specifier}} + printf("%f", 4); // expected-warning{{format specifies type 'double' but the argument has type 'int'}} + printf("%qd", lli); // no-warning + printf("%qd", x); // expected-warning{{format specifies type 'long long' but the argument has type 'int'}} + printf("%qp", (void *)0); // expected-warning{{length modifier 'q' results in undefined behavior or no effect with 'p' conversion specifier}} + printf("hhX %hhX", (unsigned char)10); // no-warning + printf("llX %llX", (long long) 10); // no-warning + // This is fine, because there is an implicit conversion to an int. + printf("%d", (unsigned char) 10); // no-warning + printf("%d", (long long) 10); // expected-warning{{format specifies type 'int' but the argument has type 'long long'}} + printf("%Lf\n", (long double) 1.0); // no-warning + printf("%f\n", (long double) 1.0); // expected-warning{{format specifies type 'double' but the argument has type 'long double'}} + // The man page says that a zero precision is okay. + printf("%.0Lf", (long double) 1.0); // no-warning + printf("%c\n", "x"); // expected-warning{{format specifies type 'int' but the argument has type 'char *'}} + printf("%c\n", 1.23); // expected-warning{{format specifies type 'int' but the argument has type 'double'}} + printf("Format %d, is %! %f", 1, 2, 4.4); // expected-warning{{invalid conversion specifier '!'}} +} + +typedef unsigned char uint8_t; + +void should_understand_small_integers() { + printf("%hhu", (short) 10); // expected-warning{{format specifies type 'unsigned char' but the argument has type 'short'}} + printf("%hu\n", (unsigned char) 1); // expected-warning{{format specifies type 'unsigned short' but the argument has type 'unsigned char'}} + printf("%hu\n", (uint8_t)1); // expected-warning{{format specifies type 'unsigned short' but the argument has type 'uint8_t'}} +} + +void test11(void *p, char *s) { + printf("%p", p); // no-warning + printf("%p", 123); // expected-warning{{format specifies type 'void *' but the argument has type 'int'}} + printf("%.4p", p); // expected-warning{{precision used with 'p' conversion specifier, resulting in undefined behavior}} + printf("%+p", p); // expected-warning{{flag '+' results in undefined behavior with 'p' conversion specifier}} + printf("% p", p); // expected-warning{{flag ' ' results in undefined behavior with 'p' conversion specifier}} + printf("%0p", p); // expected-warning{{flag '0' results in undefined behavior with 'p' conversion specifier}} + printf("%s", s); // no-warning + printf("%+s", p); // expected-warning{{flag '+' results in undefined behavior with 's' conversion specifier}} + printf("% s", p); // expected-warning{{flag ' ' results in undefined behavior with 's' conversion specifier}} + printf("%0s", p); // expected-warning{{flag '0' results in undefined behavior with 's' conversion specifier}} +} + +void test12(char *b) { + unsigned char buf[4]; + printf ("%.4s\n", buf); // no-warning + printf ("%.4s\n", &buf); // expected-warning{{format specifies type 'char *' but the argument has type 'unsigned char (*)[4]'}} + + // Verify that we are checking asprintf + asprintf(&b, "%d", "asprintf"); // expected-warning{{format specifies type 'int' but the argument has type 'char *'}} +} + +void test13(short x) { + char bel = 007; + printf("bel: '0%hhd'\n", bel); // no-warning + printf("x: '0%hhd'\n", x); // expected-warning {{format specifies type 'char' but the argument has type 'short'}} +} + +typedef struct __aslclient *aslclient; +typedef struct __aslmsg *aslmsg; +int asl_log(aslclient asl, aslmsg msg, int level, const char *format, ...) __attribute__((__format__ (__printf__, 4, 5))); +void test_asl(aslclient asl) { + // Test case from <rdar://problem/7341605>. + asl_log(asl, 0, 3, "Error: %m"); // no-warning + asl_log(asl, 0, 3, "Error: %W"); // expected-warning{{invalid conversion specifier 'W'}} +} + +// <rdar://problem/7595366> +typedef enum { A } int_t; +void f0(int_t x) { printf("%d\n", x); } + +// Unicode test cases. These are possibly specific to Mac OS X. If so, they should +// eventually be moved into a separate test. +typedef __WCHAR_TYPE__ wchar_t; + +void test_unicode_conversions(wchar_t *s) { + printf("%S", s); // no-warning + printf("%s", s); // expected-warning{{format specifies type 'char *' but the argument has type 'wchar_t *'}} + printf("%C", s[0]); // no-warning + printf("%c", s[0]); + // FIXME: This test reports inconsistent results. On Windows, '%C' expects + // 'unsigned short'. + // printf("%C", 10); + printf("%S", "hello"); // expected-warning{{but the argument has type 'char *'}} +} + +// Mac OS X supports positional arguments in format strings. +// This is an IEEE extension (IEEE Std 1003.1). +// FIXME: This is probably not portable everywhere. +void test_positional_arguments() { + printf("%0$", (int)2); // expected-warning{{position arguments in format strings start counting at 1 (not 0)}} + printf("%1$*0$d", (int) 2); // expected-warning{{position arguments in format strings start counting at 1 (not 0)}} + printf("%1$d", (int) 2); // no-warning + printf("%1$d", (int) 2, 2); // expected-warning{{data argument not used by format string}} + printf("%1$d%1$f", (int) 2); // expected-warning{{format specifies type 'double' but the argument has type 'int'}} + printf("%1$2.2d", (int) 2); // no-warning + printf("%2$*1$.2d", (int) 2, (int) 3); // no-warning + printf("%2$*8$d", (int) 2, (int) 3); // expected-warning{{specified field width is missing a matching 'int' argument}} + printf("%%%1$d", (int) 2); // no-warning + printf("%1$d%%", (int) 2); // no-warning +} + +// PR 6697 - Handle format strings where the data argument is not adjacent to the format string +void myprintf_PR_6697(const char *format, int x, ...) __attribute__((__format__(printf,1, 3))); +void test_pr_6697() { + myprintf_PR_6697("%s\n", 1, "foo"); // no-warning + myprintf_PR_6697("%s\n", 1, (int)0); // expected-warning{{format specifies type 'char *' but the argument has type 'int'}} + // FIXME: Not everything should clearly support positional arguments, + // but we need a way to identify those cases. + myprintf_PR_6697("%1$s\n", 1, "foo"); // no-warning + myprintf_PR_6697("%2$s\n", 1, "foo"); // expected-warning{{data argument position '2' exceeds the number of data arguments (1)}} + myprintf_PR_6697("%18$s\n", 1, "foo"); // expected-warning{{data argument position '18' exceeds the number of data arguments (1)}} + myprintf_PR_6697("%1$s\n", 1, (int) 0); // expected-warning{{format specifies type 'char *' but the argument has type 'int'}} +} + +void rdar8026030(FILE *fp) { + fprintf(fp, "\%"); // expected-warning{{incomplete format specifier}} +} + +void bug7377_bad_length_mod_usage() { + // Bad length modifiers + printf("%hhs", "foo"); // expected-warning{{length modifier 'hh' results in undefined behavior or no effect with 's' conversion specifier}} + printf("%1$zp", (void *)0); // expected-warning{{length modifier 'z' results in undefined behavior or no effect with 'p' conversion specifier}} + printf("%ls", L"foo"); // no-warning + printf("%#.2Lf", (long double)1.234); // no-warning + + // Bad flag usage + printf("%#p", (void *) 0); // expected-warning{{flag '#' results in undefined behavior with 'p' conversion specifier}} + printf("%0d", -1); // no-warning + printf("%#n", (void *) 0); // expected-warning{{flag '#' results in undefined behavior with 'n' conversion specifier}} expected-warning{{use of '%n' in format string discouraged (potentially insecure)}} + printf("%-n", (void *) 0); // expected-warning{{flag '-' results in undefined behavior with 'n' conversion specifier}} expected-warning{{use of '%n' in format string discouraged (potentially insecure)}} + printf("%-p", (void *) 0); // no-warning + + // Bad optional amount use + printf("%.2c", 'a'); // expected-warning{{precision used with 'c' conversion specifier, resulting in undefined behavior}} + printf("%1n", (void *) 0); // expected-warning{{field width used with 'n' conversion specifier, resulting in undefined behavior}} expected-warning{{use of '%n' in format string discouraged (potentially insecure)}} + printf("%.9n", (void *) 0); // expected-warning{{precision used with 'n' conversion specifier, resulting in undefined behavior}} expected-warning{{use of '%n' in format string discouraged (potentially insecure)}} + + // Ignored flags + printf("% +f", 1.23); // expected-warning{{flag ' ' is ignored when flag '+' is present}} + printf("%+ f", 1.23); // expected-warning{{flag ' ' is ignored when flag '+' is present}} + printf("%0-f", 1.23); // expected-warning{{flag '0' is ignored when flag '-' is present}} + printf("%-0f", 1.23); // expected-warning{{flag '0' is ignored when flag '-' is present}} + printf("%-+f", 1.23); // no-warning +} + +// PR 7981 - handle '%lc' (wint_t) +#ifndef wint_t +typedef int __darwin_wint_t; +typedef __darwin_wint_t wint_t; +#endif + +void pr7981(wint_t c, wchar_t c2) { + printf("%lc", c); // no-warning + printf("%lc", 1.0); // expected-warning{{the argument has type 'double'}} + printf("%lc", (char) 1); // no-warning + printf("%lc", &c); // expected-warning{{the argument has type 'wint_t *' (aka 'int *')}} + printf("%lc", c2); // no-warning +} + +// <rdar://problem/8269537> -Wformat-security says NULL is not a string literal +void rdar8269537() { + // This is likely to crash in most cases, but -Wformat-nonliteral technically + // doesn't warn in this case. + printf(0); // no-warning +} + +// Handle functions with multiple format attributes. +extern void rdar8332221_vprintf_scanf(const char *, va_list, const char *, ...) + __attribute__((__format__(__printf__, 1, 0))) + __attribute__((__format__(__scanf__, 3, 4))); + +void rdar8332221(va_list ap, int *x, long *y) { + rdar8332221_vprintf_scanf("%", ap, "%d", x); // expected-warning{{incomplete format specifier}} +} + +// PR8641 +void pr8641() { + printf("%#x\n", 10); + printf("%#X\n", 10); +} + +void posix_extensions() { + // Test %'d, "thousands grouping". + // <rdar://problem/8816343> + printf("%'d\n", 123456789); // no-warning + printf("%'i\n", 123456789); // no-warning + printf("%'f\n", (float) 1.0); // no-warning + printf("%'p\n", (void*) 0); // expected-warning{{results in undefined behavior with 'p' conversion specifier}} +} + +// PR8486 +// +// Test what happens when -Wformat is on, but -Wformat-security is off. +#pragma GCC diagnostic warning "-Wformat" +#pragma GCC diagnostic ignored "-Wformat-security" + +void pr8486() { + printf("%s", 1); // expected-warning{{format specifies type 'char *' but the argument has type 'int'}} +} + +// PR9314 +// Don't warn about string literals that are PreDefinedExprs, e.g. __func__. +void pr9314() { + printf(__PRETTY_FUNCTION__); // no-warning + printf(__func__); // no-warning +} + +int printf(const char * restrict, ...) __attribute__((__format__ (__printf__, 1, 2))); + +void rdar9612060(void) { + printf("%s", 2); // expected-warning{{format specifies type 'char *' but the argument has type 'int'}} +} + +void check_char(unsigned char x, signed char y) { + printf("%c", y); // no-warning + printf("%hhu", x); // no-warning + printf("%hhi", y); // no-warning + printf("%hhi", x); // no-warning + printf("%c", x); // no-warning + printf("%hhu", y); // no-warning +} + +// Test suppression of individual warnings. + +void test_suppress_invalid_specifier() { +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wformat-invalid-specifier" + printf("%@", 12); // no-warning +#pragma clang diagnostic pop +} + +// Make sure warnings are on for next test. +#pragma GCC diagnostic warning "-Wformat" +#pragma GCC diagnostic warning "-Wformat-security" + +// Test that the printf call site is where the warning is attached. If the +// format string is somewhere else, point to it in a note. +void pr9751() { + const char kFormat1[] = "%d %d \n"; // expected-note{{format string is defined here}}} + printf(kFormat1, 0); // expected-warning{{more '%' conversions than data arguments}} + printf("%d %s\n", 0); // expected-warning{{more '%' conversions than data arguments}} + + const char kFormat2[] = "%18$s\n"; // expected-note{{format string is defined here}} + printf(kFormat2, 1, "foo"); // expected-warning{{data argument position '18' exceeds the number of data arguments (2)}} + printf("%18$s\n", 1, "foo"); // expected-warning{{data argument position '18' exceeds the number of data arguments (2)}} + + const char kFormat3[] = "%n"; // expected-note{{format string is defined here}} + printf(kFormat3, "as"); // expected-warning{{use of '%n' in format string discouraged}} + printf("%n", "as"); // expected-warning{{use of '%n' in format string discouraged}} + + const char kFormat4[] = "%y"; // expected-note{{format string is defined here}} + printf(kFormat4, 5); // expected-warning{{invalid conversion specifier 'y'}} + printf("%y", 5); // expected-warning{{invalid conversion specifier 'y'}} + + const char kFormat5[] = "%."; // expected-note{{format string is defined here}} + printf(kFormat5, 5); // expected-warning{{incomplete format specifier}} + printf("%.", 5); // expected-warning{{incomplete format specifier}} + + const char kFormat6[] = "%s"; // expected-note{{format string is defined here}} + printf(kFormat6, 5); // expected-warning{{format specifies type 'char *' but the argument has type 'int'}} + printf("%s", 5); // expected-warning{{format specifies type 'char *' but the argument has type 'int'}} + + const char kFormat7[] = "%0$"; // expected-note{{format string is defined here}} + printf(kFormat7, 5); // expected-warning{{position arguments in format strings start counting at 1 (not 0)}} + printf("%0$", 5); // expected-warning{{position arguments in format strings start counting at 1 (not 0)}} + + const char kFormat8[] = "%1$d %d"; // expected-note{{format string is defined here}} + printf(kFormat8, 4, 4); // expected-warning{{cannot mix positional and non-positional arguments in format string}} + printf("%1$d %d", 4, 4); // expected-warning{{cannot mix positional and non-positional arguments in format string}} + + const char kFormat9[] = ""; // expected-note{{format string is defined here}} + printf(kFormat9, 4, 4); // expected-warning{{format string is empty}} + printf("", 4, 4); // expected-warning{{format string is empty}} + + const char kFormat10[] = "\0%d"; // expected-note{{format string is defined here}} + printf(kFormat10, 4); // expected-warning{{format string contains '\0' within the string body}} + printf("\0%d", 4); // expected-warning{{format string contains '\0' within the string body}} + + const char kFormat11[] = "%*d"; // expected-note{{format string is defined here}} + printf(kFormat11); // expected-warning{{'*' specified field width is missing a matching 'int' argument}} + printf("%*d"); // expected-warning{{'*' specified field width is missing a matching 'int' argument}} + + const char kFormat12[] = "%*d"; // expected-note{{format string is defined here}} + printf(kFormat12, 4.4); // expected-warning{{field width should have type 'int', but argument has type 'double'}} + printf("%*d", 4.4); // expected-warning{{field width should have type 'int', but argument has type 'double'}} + + const char kFormat13[] = "%.3p"; // expected-note{{format string is defined here}} + void *p; + printf(kFormat13, p); // expected-warning{{precision used with 'p' conversion specifier, resulting in undefined behavior}} + printf("%.3p", p); // expected-warning{{precision used with 'p' conversion specifier, resulting in undefined behavior}} + + const char kFormat14[] = "%0s"; // expected-note{{format string is defined here}} + printf(kFormat14, "a"); // expected-warning{{flag '0' results in undefined behavior with 's' conversion specifier}} + printf("%0s", "a"); // expected-warning{{flag '0' results in undefined behavior with 's' conversion specifier}} + + const char kFormat15[] = "%hhs"; // expected-note{{format string is defined here}} + printf(kFormat15, "a"); // expected-warning{{length modifier 'hh' results in undefined behavior or no effect with 's' conversion specifier}} + printf("%hhs", "a"); // expected-warning{{length modifier 'hh' results in undefined behavior or no effect with 's' conversion specifier}} + + const char kFormat16[] = "%-0d"; // expected-note{{format string is defined here}} + printf(kFormat16, 5); // expected-warning{{flag '0' is ignored when flag '-' is present}} + printf("%-0d", 5); // expected-warning{{flag '0' is ignored when flag '-' is present}} + + // Make sure that the "format string is defined here" note is not emitted + // when the original string is within the argument expression. + printf(1 ? "yes %d" : "no %d"); // expected-warning 2{{more '%' conversions than data arguments}} + + const char kFormat17[] = "%hu"; // expected-note{{format string is defined here}}} + printf(kFormat17, (int[]){0}); // expected-warning{{format specifies type 'unsigned short' but the argument}} + + printf("%a", (long double)0); // expected-warning{{format specifies type 'double' but the argument has type 'long double'}} +} + +// PR 9466: clang: doesn't know about %Lu, %Ld, and %Lx +void printf_longlong(long long x, unsigned long long y) { + printf("%Ld", y); // no-warning + printf("%Lu", y); // no-warning + printf("%Lx", y); // no-warning + printf("%Ld", x); // no-warning + printf("%Lu", x); // no-warning + printf("%Lx", x); // no-warning + printf("%Ls", "hello"); // expected-warning {{length modifier 'L' results in undefined behavior or no effect with 's' conversion specifier}} +} + +void __attribute__((format(strfmon,1,2))) monformat(const char *fmt, ...); +void __attribute__((format(strftime,1,0))) dateformat(const char *fmt); + +// Other formats +void test_other_formats() { + char *str = ""; + monformat("", 1); // expected-warning{{format string is empty}} + monformat(str); // expected-warning{{format string is not a string literal (potentially insecure)}} + dateformat(""); // expected-warning{{format string is empty}} + dateformat(str); // no-warning (using strftime non literal is not unsafe) +} diff --git a/clang/test/Sema/fp16-sema.c b/clang/test/Sema/fp16-sema.c new file mode 100644 index 0000000..e678f9a --- /dev/null +++ b/clang/test/Sema/fp16-sema.c @@ -0,0 +1,30 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// Functions cannot have parameters of type __fp16. +extern void f (__fp16); // expected-error {{parameters cannot have __fp16 type; did you forget * ?}} +extern void g (__fp16 *); + +extern void (*pf) (__fp16); // expected-error {{parameters cannot have __fp16 type; did you forget * ?}} +extern void (*pg) (__fp16*); + +typedef void(*tf) (__fp16); // expected-error {{parameters cannot have __fp16 type; did you forget * ?}} +typedef void(*tg) (__fp16*); + +void kf(a) + __fp16 a; { // expected-error {{parameters cannot have __fp16 type; did you forget * ?}} +} + +void kg(a) + __fp16 *a; { +} + +// Functions cannot return type __fp16. +extern __fp16 f1 (void); // expected-error {{function return value cannot have __fp16 type; did you forget * ?}} +extern __fp16 *g1 (void); + +extern __fp16 (*pf1) (void); // expected-error {{function return value cannot have __fp16 type; did you forget * ?}} +extern __fp16 *(*gf1) (void); + +typedef __fp16 (*tf1) (void); // expected-error {{function return value cannot have __fp16 type; did you forget * ?}} +typedef __fp16 *(*tg1) (void); + diff --git a/clang/test/Sema/fpack-struct.c b/clang/test/Sema/fpack-struct.c new file mode 100644 index 0000000..37c8444 --- /dev/null +++ b/clang/test/Sema/fpack-struct.c @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 -DEXPECTED_STRUCT_SIZE=5 -fpack-struct 1 %s +// RUN: %clang_cc1 -DEXPECTED_STRUCT_SIZE=6 -fpack-struct 2 %s + +struct s0 { + int x; + char c; +}; + +int t0[sizeof(struct s0) == EXPECTED_STRUCT_SIZE ?: -1]; diff --git a/clang/test/Sema/freemain.c b/clang/test/Sema/freemain.c new file mode 100644 index 0000000..eed644d --- /dev/null +++ b/clang/test/Sema/freemain.c @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -ffreestanding %s + +// Tests that -ffreestanding disables all special treatment of main(). + +void* allocate(long size); + +void* main(void* context, long size) { + if (context) return allocate(size); +} // expected-warning {{control may reach end of non-void function}} diff --git a/clang/test/Sema/function-ptr.c b/clang/test/Sema/function-ptr.c new file mode 100644 index 0000000..ff85272 --- /dev/null +++ b/clang/test/Sema/function-ptr.c @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 %s -verify -pedantic +typedef int unary_int_func(int arg); +unary_int_func *func; + +unary_int_func *set_func(void *p) { + func = p; // expected-warning {{converts between void pointer and function pointer}} + p = func; // expected-warning {{converts between void pointer and function pointer}} + + return p; // expected-warning {{converts between void pointer and function pointer}} +} + diff --git a/clang/test/Sema/function-redecl.c b/clang/test/Sema/function-redecl.c new file mode 100644 index 0000000..7076bdf --- /dev/null +++ b/clang/test/Sema/function-redecl.c @@ -0,0 +1,131 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// PR3588 +void g0(int, int); +void g0(); // expected-note{{previous declaration is here}} expected-note{{'g0' declared here}} + +void f0() { + g0(1, 2, 3); // expected-error{{too many arguments to function call}} +} + +void g0(int); // expected-error{{conflicting types for 'g0'}} + +int g1(int, int); + +typedef int INT; + +INT g1(x, y) + int x; + int y; +{ + return x + y; +} + +int g2(int, int); // expected-note{{previous declaration is here}} + +INT g2(x) // expected-error{{conflicting types for 'g2'}} + int x; +{ + return x; +} + +void test() { + int f1; + { + void f1(double); + { + void f1(double); // expected-note{{previous declaration is here}} + { + int f1(int); // expected-error{{conflicting types for 'f1'}} + } + } + } +} + +extern void g3(int); // expected-note{{previous declaration is here}} +static void g3(int x) { } // expected-error{{static declaration of 'g3' follows non-static declaration}} + +void test2() { + extern int f2; // expected-note 2 {{previous definition is here}} + { + void f2(int); // expected-error{{redefinition of 'f2' as different kind of symbol}} + } + + { + int f2; + { + void f2(int); // expected-error{{redefinition of 'f2' as different kind of symbol}} + } + } +} + +// <rdar://problem/6127293> +int outer1(int); // expected-note{{previous declaration is here}} +struct outer3 { }; +int outer4(int); +int outer5; // expected-note{{previous definition is here}} +int *outer7(int); + +void outer_test() { + int outer1(float); // expected-error{{conflicting types for 'outer1'}} + int outer2(int); // expected-note{{previous declaration is here}} + int outer3(int); // expected-note{{previous declaration is here}} + int outer4(int); // expected-note{{previous declaration is here}} + int outer5(int); // expected-error{{redefinition of 'outer5' as different kind of symbol}} + int* outer6(int); // expected-note{{previous declaration is here}} + int *outer7(int); + int outer8(int); + + int *ip7 = outer7(6); +} + +int outer2(float); // expected-error{{conflicting types for 'outer2'}} +int outer3(float); // expected-error{{conflicting types for 'outer3'}} +int outer4(float); // expected-error{{conflicting types for 'outer4'}} + +void outer_test2(int x) { + int* ip = outer6(x); // expected-warning{{use of out-of-scope declaration of 'outer6'}} + int *ip2 = outer7(x); +} + +void outer_test3() { + int *(*fp)(int) = outer8; // expected-error{{use of undeclared identifier 'outer8'}} +} + +static float outer8(float); // okay + +enum e { e1, e2 }; + +// GNU extension: prototypes and K&R function definitions +int isroot(short x, // expected-note{{previous declaration is here}} + enum e); + +int isroot(x, y) + short x; // expected-warning{{promoted type 'int' of K&R function parameter is not compatible with the parameter type 'short' declared in a previous prototype}} + unsigned int y; +{ + return x == 1; +} + +// PR3817 +void *h0(unsigned a0, ...); +extern __typeof (h0) h1 __attribute__((__sentinel__)); +extern __typeof (h1) h1 __attribute__((__sentinel__)); + +// PR3840 +void i0 (unsigned short a0); +extern __typeof (i0) i1; +extern __typeof (i1) i1; + +typedef int a(); +typedef int a2(int*); +a x; +a2 x2; // expected-note{{passing argument to parameter here}} +void test_x() { + x(5); + x2(5); // expected-warning{{incompatible integer to pointer conversion passing 'int' to parameter of type 'int *'}} +} + +enum e0 {one}; +void f3(); +void f3(enum e0 x) {} diff --git a/clang/test/Sema/function.c b/clang/test/Sema/function.c new file mode 100644 index 0000000..1b0dc2a --- /dev/null +++ b/clang/test/Sema/function.c @@ -0,0 +1,94 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify -pedantic + +// PR1892, PR11354 +void f(double a[restrict][5]) { __typeof(a) x = 10; } // expected-warning {{(aka 'double (*restrict)[5]')}} + +int foo (__const char *__path); +int foo(__const char *__restrict __file); + +void func(const char*); // expected-note {{previous declaration is here}} +void func(char*); // expected-error{{conflicting types for 'func'}} + +void g(int (*)(const void **, const void **)); +void g(int (*compar)()) { +} + +void h(); // expected-note {{previous declaration is here}} +void h (const char *fmt, ...) {} // expected-error{{conflicting types for 'h'}} + +// PR1965 +int t5(b); // expected-error {{parameter list without types}} +int t6(int x, g); // expected-warning {{type specifier missing, defaults to 'int'}} + +int t7(, ); // expected-error {{expected parameter declarator}} expected-error {{expected parameter declarator}} +int t8(, int a); // expected-error {{expected parameter declarator}} +int t9(int a, ); // expected-error {{expected parameter declarator}} + + +// PR2042 +void t10(){} +void t11(){t10(1);} // expected-warning{{too many arguments}} + +// PR3208 +void t12(int) {} // expected-error{{parameter name omitted}} + +// PR2790 +void t13() { + return 0; // expected-error {{void function 't13' should not return a value}} +} +int t14() { + return; // expected-error {{non-void function 't14' should return a value}} +} + +// <rdar://problem/6097326> +y(y) { return y; } // expected-warning{{parameter 'y' was not declared, defaulting to type 'int'}} \ + // expected-warning{{type specifier missing, defaults to 'int'}} + + +// PR3137, <rdar://problem/6127293> +extern int g0_3137(void); +void f0_3137() { + int g0_3137(void); +} +void f1_3137() { + int (*fp)(void) = g0_3137; +} + +void f1static() { + static void f2static(int); // expected-error{{function declared in block scope cannot have 'static' storage class}} + register void f2register(int); // expected-error{{illegal storage class on function}} +} + +struct incomplete_test a(void) {} // expected-error{{incomplete result type 'struct incomplete_test' in function definition}} \ + // expected-note{{forward declaration of 'struct incomplete_test'}} + + +extern __inline +__attribute__((__gnu_inline__)) +void gnu_inline1() {} + +void +__attribute__((__gnu_inline__)) // expected-warning {{'gnu_inline' attribute requires function to be marked 'inline', attribute ignored}} +gnu_inline2() {} + + +// rdar://6802350 +inline foo_t invalid_type() { // expected-error {{unknown type name 'foo_t'}} +} + +typedef void fn_t(void); +fn_t t17; + +// PR4049 +unknown_type t18(void*) { // expected-error {{unknown type name 'unknown_type'}} expected-error{{parameter name omitted}} +} + +unknown_type t19(int* P) { // expected-error {{unknown type name 'unknown_type'}} + P = P+1; // no warning. +} + +// missing ',' before '...' +void t20(int i...) { } // expected-error {{requires a comma}} + +int n; +void t21(int n, int (*array)[n]); diff --git a/clang/test/Sema/generic-selection.c b/clang/test/Sema/generic-selection.c new file mode 100644 index 0000000..8cef975 --- /dev/null +++ b/clang/test/Sema/generic-selection.c @@ -0,0 +1,26 @@ +// RUN: %clang_cc1 -std=c1x -fsyntax-only -verify %s + +void foo(int n) { + (void) _Generic(0, + struct A: 0, // expected-error {{type 'struct A' in generic association incomplete}} + void(): 0, // expected-error {{type 'void ()' in generic association not an object type}} + int[n]: 0); // expected-error {{type 'int [n]' in generic association is a variably modified type}} + + (void) _Generic(0, + void (*)(): 0, // expected-note {{compatible type 'void (*)()' specified here}} + void (*)(void): 0); // expected-error {{type 'void (*)(void)' in generic association compatible with previously specified type 'void (*)()'}} + + (void) _Generic((void (*)()) 0, // expected-error {{controlling expression type 'void (*)()' compatible with 2 generic association types}} + void (*)(int): 0, // expected-note {{compatible type 'void (*)(int)' specified here}} + void (*)(void): 0); // expected-note {{compatible type 'void (*)(void)' specified here}} + + (void) _Generic(0, // expected-error {{controlling expression type 'int' not compatible with any generic association type}} + char: 0, short: 0, long: 0); + + int a1[_Generic(0, int: 1, short: 2, float: 3, default: 4) == 1 ? 1 : -1]; + int a2[_Generic(0, default: 1, short: 2, float: 3, int: 4) == 4 ? 1 : -1]; + int a3[_Generic(0L, int: 1, short: 2, float: 3, default: 4) == 4 ? 1 : -1]; + int a4[_Generic(0L, default: 1, short: 2, float: 3, int: 4) == 1 ? 1 : -1]; + int a5[_Generic(0, int: 1, short: 2, float: 3) == 1 ? 1 : -1]; + int a6[_Generic(0, short: 1, float: 2, int: 3) == 3 ? 1 : -1]; +} diff --git a/clang/test/Sema/gnu89.c b/clang/test/Sema/gnu89.c new file mode 100644 index 0000000..189e6b0 --- /dev/null +++ b/clang/test/Sema/gnu89.c @@ -0,0 +1,5 @@ +// RUN: %clang_cc1 %s -std=gnu89 -pedantic -fsyntax-only -verify + +int f(int restrict); + +void main() {} // expected-warning {{return type of 'main' is not 'int'}} diff --git a/clang/test/Sema/heinous-extensions-off.c b/clang/test/Sema/heinous-extensions-off.c new file mode 100644 index 0000000..9b80d34 --- /dev/null +++ b/clang/test/Sema/heinous-extensions-off.c @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 %s -verify + +int foo() { + int a; + // PR3788 + asm("nop" : : "m"((int)(a))); // expected-error {{cast in a inline asm context requiring an l-value}} + // PR3794 + asm("nop" : "=r"((unsigned)a)); // expected-error {{cast in a inline asm context requiring an l-value}} +} + diff --git a/clang/test/Sema/heinous-extensions-on.c b/clang/test/Sema/heinous-extensions-on.c new file mode 100644 index 0000000..176f472 --- /dev/null +++ b/clang/test/Sema/heinous-extensions-on.c @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 %s -verify -fheinous-gnu-extensions + +void foo() { + int a; + // PR3788 + asm("nop" : : "m"((int)(a))); // expected-warning {{cast in a inline asm context requiring an l-value}} + // PR3794 + asm("nop" : "=r"((unsigned)a)); // expected-warning {{cast in a inline asm context requiring an l-value}} +} diff --git a/clang/test/Sema/i-c-e.c b/clang/test/Sema/i-c-e.c new file mode 100644 index 0000000..ee61ac3 --- /dev/null +++ b/clang/test/Sema/i-c-e.c @@ -0,0 +1,75 @@ +// RUN: %clang %s -ffreestanding -fsyntax-only -Xclang -verify -pedantic -fpascal-strings -std=c99 + +#include <stdint.h> +#include <limits.h> + +int a() {int p; *(1 ? &p : (void*)(0 && (a(),1))) = 10;} // expected-error {{incomplete type 'void' is not assignable}} + +// rdar://6091492 - ?: with __builtin_constant_p as the operand is an i-c-e. +int expr; +char w[__builtin_constant_p(expr) ? expr : 1]; + +char v[sizeof(__builtin_constant_p(0)) == sizeof(int) ? 1 : -1]; + +int implicitConversion = 1.0; +char floatArith[(int)(1.0+2.0)]; // expected-warning {{must be an integer constant expression}} + +// __builtin_constant_p as the condition of ?: allows arbitrary foldable +// constants to be transmogrified into i-c-e's. +char b[__builtin_constant_p((int)(1.0+2.0)) ? (int)(1.0+2.0) : -1]; + +struct c { + int a : ( + __builtin_constant_p((int)(1.0+2.0)) ? (int)(1.0+ + expr // expected-error {{expression is not an integer constant expression}} + ) : -1); +}; + + + + +void test1(int n, int* p) { *(n ? p : (void *)(7-7)) = 1; } +void test2(int n, int* p) { *(n ? p : (void *)0) = 1; } + + + +char array[1024/(sizeof (long))]; + +int x['\xBb' == (char) 187 ? 1: -1]; + +// PR1992 +void func(int x) +{ + switch (x) { + case sizeof("abc"): break; + case sizeof("loooong"): func(4); + case sizeof("\ploooong"): func(4); + } +} + + +// rdar://4213768 +int expr; +char y[__builtin_constant_p(expr) ? -1 : 1]; +char z[__builtin_constant_p(4) ? 1 : -1]; + +// Comma tests +int comma1[0?1,2:3]; +int comma2[1||(1,2)]; // expected-warning {{use of logical '||' with constant operand}} \ + // expected-note {{use '|' for a bitwise operation}} +int comma3[(1,2)]; // expected-warning {{size of static array must be an integer constant expression}} + +// Pointer + __builtin_constant_p +char pbcp[__builtin_constant_p(4) ? (intptr_t)&expr : 0]; // expected-error {{variable length array declaration not allowed at file scope}} + +int illegaldiv1a[1 || 1/0]; +int illegaldiv1b[1 && 1/0]; //expected-error{{variable length array declaration not allowed at file scope}} + +int illegaldiv2[1/0]; // expected-error {{variable length array declaration not allowed at file scope}} +int illegaldiv3[INT_MIN / -1]; // expected-error {{variable length array declaration not allowed at file scope}} +// PR9262 +int illegaldiv4[0 / (1 / 0)]; // expected-error {{variable length array declaration not allowed at file scope}} + +int chooseexpr[__builtin_choose_expr(1, 1, expr)]; +int realop[(__real__ 4) == 4 ? 1 : -1]; +int imagop[(__imag__ 4) == 0 ? 1 : -1]; diff --git a/clang/test/Sema/illegal-types.c b/clang/test/Sema/illegal-types.c new file mode 100644 index 0000000..819b38a --- /dev/null +++ b/clang/test/Sema/illegal-types.c @@ -0,0 +1,7 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -x c++ -std=c++98 %s + +void a (void []()); // expected-error{{'type name' declared as array of functions}} +void b (void p[]()); // expected-error{{'p' declared as array of functions}} +void c (int &[]); // expected-error{{'type name' declared as array of references}} +void d (int &p[]); // expected-error{{'p' declared as array of references}} + diff --git a/clang/test/Sema/implicit-builtin-decl.c b/clang/test/Sema/implicit-builtin-decl.c new file mode 100644 index 0000000..8cdd365 --- /dev/null +++ b/clang/test/Sema/implicit-builtin-decl.c @@ -0,0 +1,57 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +void f() { + int *ptr = malloc(sizeof(int) * 10); // expected-warning{{implicitly declaring library function 'malloc' with type}} \ + // expected-note{{please include the header <stdlib.h> or explicitly provide a declaration for 'malloc'}} \ + // expected-note{{'malloc' is a builtin with type 'void *}} +} + +void *alloca(__SIZE_TYPE__); // redeclaration okay + +int *calloc(__SIZE_TYPE__, __SIZE_TYPE__); // expected-warning{{incompatible redeclaration of library function 'calloc'}} \ + // expected-note{{'calloc' is a builtin with type 'void *}} + + +void g(int malloc) { // okay: these aren't functions + int calloc = 1; +} + +void h() { + int malloc(int); // expected-warning{{incompatible redeclaration of library function 'malloc'}} + int strcpy(int); // expected-warning{{incompatible redeclaration of library function 'strcpy'}} \ + // expected-note{{'strcpy' is a builtin with type 'char *(char *, const char *)'}} +} + +void f2() { + fprintf(0, "foo"); // expected-warning{{declaration of built-in function 'fprintf' requires inclusion of the header <stdio.h>}} \ + expected-warning {{implicit declaration of function 'fprintf' is invalid in C99}} +} + +// PR2892 +void __builtin_object_size(); // expected-error{{conflicting types}} \ +// expected-note{{'__builtin_object_size' is a builtin with type}} + +int a[10]; + +int f0() { + return __builtin_object_size(&a); // expected-error {{too few arguments to function}} +} + +void * realloc(void *p, int size) { // expected-warning{{incompatible redeclaration of library function 'realloc'}} \ +// expected-note{{'realloc' is a builtin with type 'void *(void *,}} + return p; +} + +// PR3855 +void snprintf(); // expected-warning{{incompatible redeclaration of library function 'snprintf'}} \ + // expected-note{{'snprintf' is a builtin}} + +int +main(int argc, char *argv[]) +{ + snprintf(); +} + +void snprintf() { } + +// PR8316 +void longjmp(); // expected-warning{{declaration of built-in function 'longjmp' requires inclusion of the header <setjmp.h>}} diff --git a/clang/test/Sema/implicit-builtin-freestanding.c b/clang/test/Sema/implicit-builtin-freestanding.c new file mode 100644 index 0000000..505e522 --- /dev/null +++ b/clang/test/Sema/implicit-builtin-freestanding.c @@ -0,0 +1,4 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -ffreestanding %s + +int malloc(int a) { return a; } + diff --git a/clang/test/Sema/implicit-builtin-redecl.c b/clang/test/Sema/implicit-builtin-redecl.c new file mode 100644 index 0000000..9fb7e62 --- /dev/null +++ b/clang/test/Sema/implicit-builtin-redecl.c @@ -0,0 +1,26 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// PR3592 +static void* malloc(int); +static void* malloc(int size) { + return ((void*)0); /*do not use heap in this file*/ +} + +void *calloc(int, int, int); // expected-warning{{incompatible redeclaration of library function 'calloc'}} \ +// expected-note{{'calloc' is a builtin with type 'void *}} + +void f1(void) { + calloc(0, 0, 0); +} + +void f2() { + int index = 1; +} + +static int index; + +int f3() { + return index << 2; +} + +typedef int rindex; diff --git a/clang/test/Sema/implicit-cast.c b/clang/test/Sema/implicit-cast.c new file mode 100644 index 0000000..088b195 --- /dev/null +++ b/clang/test/Sema/implicit-cast.c @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 -fsyntax-only %s + +static char *test1(int cf) { + return cf ? "abc" : 0; +} +static char *test2(int cf) { + return cf ? 0 : "abc"; +} diff --git a/clang/test/Sema/implicit-decl.c b/clang/test/Sema/implicit-decl.c new file mode 100644 index 0000000..ffab9a6 --- /dev/null +++ b/clang/test/Sema/implicit-decl.c @@ -0,0 +1,32 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only -Werror + +typedef int int32_t; +typedef unsigned char Boolean; + +extern int printf(__const char *__restrict __format, ...); // expected-note{{'printf' declared here}} + +void func() { + int32_t *vector[16]; + const char compDesc[16 + 1]; + int32_t compCount = 0; + if (_CFCalendarDecomposeAbsoluteTimeV(compDesc, vector, compCount)) { // expected-note {{previous implicit declaration is here}} \ + expected-error {{implicit declaration of function '_CFCalendarDecomposeAbsoluteTimeV' is invalid in C99}} + } + + printg("Hello, World!\n"); // expected-error{{implicit declaration of function 'printg' is invalid in C99}} \ + // expected-note{{did you mean 'printf'?}} + + __builtin_is_les(1, 3); // expected-error{{use of unknown builtin '__builtin_is_les'}} +} +Boolean _CFCalendarDecomposeAbsoluteTimeV(const char *componentDesc, int32_t **vector, int32_t count) { // expected-error{{conflicting types for '_CFCalendarDecomposeAbsoluteTimeV'}} + return 0; +} + + +// Test the typo-correction callback in Sema::ImplicitlyDefineFunction +extern int sformatf(char *str, __const char *__restrict __format, ...); // expected-note{{'sformatf' declared here}} +void test_implicit() { + int formats = 0; + formatd("Hello, World!\n"); // expected-error{{implicit declaration of function 'formatd' is invalid in C99}} \ + // expected-note{{did you mean 'sformatf'?}} +} diff --git a/clang/test/Sema/implicit-def.c b/clang/test/Sema/implicit-def.c new file mode 100644 index 0000000..6caa090 --- /dev/null +++ b/clang/test/Sema/implicit-def.c @@ -0,0 +1,8 @@ +/* RUN: %clang_cc1 -fsyntax-only %s -std=c89 + * RUN: not %clang_cc1 -fsyntax-only %s -std=c99 -pedantic-errors + */ + +int A() { + return X(); +} + diff --git a/clang/test/Sema/implicit-int.c b/clang/test/Sema/implicit-int.c new file mode 100644 index 0000000..3063db6 --- /dev/null +++ b/clang/test/Sema/implicit-int.c @@ -0,0 +1,28 @@ +// RUN: %clang_cc1 -fsyntax-only %s -verify -pedantic + +foo() { // expected-warning {{type specifier missing, defaults to 'int'}} + return 0; +} + +y; // expected-warning {{type specifier missing, defaults to 'int'}} + +// rdar://6131634 +void f((x)); // expected-warning {{type specifier missing, defaults to 'int'}} + + +// PR3702 +#define PAD(ms10) { \ + register i; \ +} + +#define ILPAD() PAD((NROW - tt.tt_row) * 10) /* 1 ms per char */ + +void +h19_insline(n) // expected-warning {{parameter 'n' was not declared, defaulting to type 'int'}} +{ + ILPAD(); // expected-warning {{type specifier missing, defaults to 'int'}} +} + +struct foo { + __extension__ __attribute__((packed)) x : 4; // expected-warning {{type specifier missing, defaults to 'int'}} +}; diff --git a/clang/test/Sema/incompatible-sign.c b/clang/test/Sema/incompatible-sign.c new file mode 100644 index 0000000..6249feb --- /dev/null +++ b/clang/test/Sema/incompatible-sign.c @@ -0,0 +1,5 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only + +int a(int* x); // expected-note{{passing argument to parameter 'x' here}} +int b(unsigned* y) { return a(y); } // expected-warning {{passing 'unsigned int *' to parameter of type 'int *' converts between pointers to integer types with different sign}} + diff --git a/clang/test/Sema/incomplete-call.c b/clang/test/Sema/incomplete-call.c new file mode 100644 index 0000000..d34bda5 --- /dev/null +++ b/clang/test/Sema/incomplete-call.c @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +struct foo; // expected-note 3 {{forward declaration of 'struct foo'}} + +struct foo a(); // expected-note {{'a' declared here}} +void b(struct foo); +void c(); + +void func(void *p) { + a(); // expected-error{{calling 'a' with incomplete return type 'struct foo'}} + b(*(struct foo*)p); // expected-error{{argument type 'struct foo' is incomplete}} + c(*(struct foo*)p); // expected-error{{argument type 'struct foo' is incomplete}} +} diff --git a/clang/test/Sema/incomplete-decl.c b/clang/test/Sema/incomplete-decl.c new file mode 100644 index 0000000..0214a0c --- /dev/null +++ b/clang/test/Sema/incomplete-decl.c @@ -0,0 +1,31 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +struct foo; // expected-note 5 {{forward declaration of 'struct foo'}} + +void b; // expected-error {{variable has incomplete type 'void'}} +struct foo f; // expected-error{{tentative definition has type 'struct foo' that is never completed}} + +static void c; // expected-error {{variable has incomplete type 'void'}} +static struct foo g; // expected-warning {{tentative definition of variable with internal linkage has incomplete non-array type 'struct foo'}} \ + expected-error{{tentative definition has type 'struct foo' that is never completed}} + +extern void d; +extern struct foo e; + +int ary[]; // expected-warning {{tentative array definition assumed to have one element}} +struct foo bary[]; // expected-error {{array has incomplete element type 'struct foo'}} + +void func() { + int ary[]; // expected-error{{definition of variable with array type needs an explicit size or an initializer}} + void b; // expected-error {{variable has incomplete type 'void'}} + struct foo f; // expected-error {{variable has incomplete type 'struct foo'}} +} + +int h[]; // expected-warning {{tentative array definition assumed to have one element}} +int (*i)[] = &h+1; // expected-error {{arithmetic on a pointer to an incomplete type 'int []'}} + +struct bar j = {1}; // expected-error {{variable has incomplete type 'struct bar'}} \ + expected-note {{forward declaration of 'struct bar'}} +struct bar k; +struct bar { int a; }; + diff --git a/clang/test/Sema/indirect-goto.c b/clang/test/Sema/indirect-goto.c new file mode 100644 index 0000000..4c1c6c3 --- /dev/null +++ b/clang/test/Sema/indirect-goto.c @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +struct c {int x;}; +int a(struct c x, long long y) { + void const* l1_ptr = &&l1; + goto *l1_ptr; +l1: + goto *x; // expected-error{{incompatible type}} + goto *y; // expected-warning{{incompatible integer to pointer conversion}} +} + diff --git a/clang/test/Sema/init-struct-qualified.c b/clang/test/Sema/init-struct-qualified.c new file mode 100644 index 0000000..49ec7cc --- /dev/null +++ b/clang/test/Sema/init-struct-qualified.c @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 -fsyntax-only -verify < %s +typedef float CGFloat; +typedef struct _NSPoint { CGFloat x; CGFloat y; } NSPoint; +typedef struct _NSSize { CGFloat width; CGFloat height; } NSSize; +typedef struct _NSRect { NSPoint origin; NSSize size; } NSRect; + +extern const NSPoint NSZeroPoint; + +extern NSSize canvasSize(); +void func() { + const NSRect canvasRect = { NSZeroPoint, canvasSize() }; +} diff --git a/clang/test/Sema/init-vector.c b/clang/test/Sema/init-vector.c new file mode 100644 index 0000000..f0cf32b --- /dev/null +++ b/clang/test/Sema/init-vector.c @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +typedef float __attribute__((vector_size (16))) v4f_t; + +typedef union { + struct { + float x, y, z, w; + }s; + v4f_t v; +} vector_t; + + +vector_t foo(v4f_t p) +{ + vector_t v = {.v = p}; + return v; +} diff --git a/clang/test/Sema/init.c b/clang/test/Sema/init.c new file mode 100644 index 0000000..81a665d --- /dev/null +++ b/clang/test/Sema/init.c @@ -0,0 +1,159 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only -ffreestanding + +#include <stddef.h> +#include <stdint.h> + +typedef void (* fp)(void); +void foo(void); + +// PR clang/3377 +fp a[(short int)1] = { foo }; + +int myArray[5] = {1, 2, 3, 4, 5}; +int *myPointer2 = myArray; +int *myPointer = &(myArray[2]); + + +extern int x; +void *g = &x; +int *h = &x; + +struct union_crash +{ + union + { + }; +}; + +int test() { + int a[10]; + int b[10] = a; // expected-error {{array initializer must be an initializer list}} + int +; // expected-error {{expected identifier or '('}} + + struct union_crash u = { .d = 1 }; // expected-error {{field designator 'd' does not refer to any field in type 'struct union_crash'}} +} + + +// PR2050 +struct cdiff_cmd { + const char *name; + unsigned short argc; + int (*handler)(); +}; +int cdiff_cmd_open(); +struct cdiff_cmd commands[] = { + {"OPEN", 1, &cdiff_cmd_open } +}; + +// PR2348 +static struct { int z; } s[2]; +int *t = &(*s).z; + +// PR2349 +short *a2(void) +{ + short int b; + static short *bp = &b; // expected-error {{initializer element is not a compile-time constant}} + + return bp; +} + +int pbool(void) { + typedef const _Bool cbool; + _Bool pbool1 = (void *) 0; + cbool pbool2 = &pbool; + return pbool2; +} + + +// rdar://5870981 +union { float f; unsigned u; } u = { 1.0f }; + +// rdar://6156694 +int f3(int x) { return x; } +typedef void (*vfunc)(void); +void *bar = (vfunc) f3; + +// PR2747 +struct sym_reg { + char nc_gpreg; +}; +int sym_fw1a_scr[] = { + ((int)(&((struct sym_reg *)0)->nc_gpreg)) & 0, + 8 * ((int)(&((struct sym_reg *)0)->nc_gpreg)) +}; + +// PR3001 +struct s1 s2 = { // expected-error {{variable has incomplete type 'struct s1'}} \ + // expected-note {{forward declaration of 'struct s1'}} + .a = sizeof(struct s3), // expected-error {{invalid application of 'sizeof'}} \ + // expected-note{{forward declaration of 'struct s3'}} + .b = bogus // expected-error {{use of undeclared identifier 'bogus'}} +} + +// PR3382 +char t[] = ("Hello"); + +// <rdar://problem/6094855> +typedef struct { } empty; + +typedef struct { + empty e; + int i2; +} st; + +st st1 = { .i2 = 1 }; + +// <rdar://problem/6096826> +struct { + int a; + int z[2]; +} y = { .z = {} }; + +int bbb[10]; + +struct foo2 { + uintptr_t a; +}; + +struct foo2 bar2[] = { + { (intptr_t)bbb } +}; + +struct foo2 bar3 = { 1, 2 }; // expected-warning{{excess elements in struct initializer}} + +int* ptest1 = __builtin_choose_expr(1, (int*)0, (int*)0); + +typedef int32_t ivector4 __attribute((vector_size(16))); +ivector4 vtest1 = 1 ? (ivector4){1} : (ivector4){1}; +ivector4 vtest2 = __builtin_choose_expr(1, (ivector4){1}, (ivector4){1}); + +uintptr_t ptrasintadd1 = (uintptr_t)&a - 4; +uintptr_t ptrasintadd2 = (uintptr_t)&a + 4; +uintptr_t ptrasintadd3 = 4 + (uintptr_t)&a; + +// PR4285 +const wchar_t widestr[] = L"asdf"; + +// PR5447 +const double pr5447 = (0.05 < -1.0) ? -1.0 : 0.0499878; + +// PR4386 + +// None of these are constant initializers, but we implement GCC's old +// behaviour of accepting bar and zed but not foo. GCC's behaviour was +// changed in 2007 (rev 122551), so we should be able to change too one +// day. +int PR4386_bar(); +int PR4386_foo() __attribute((weak)); +int PR4386_zed(); + +int PR4386_a = ((void *) PR4386_bar) != 0; +int PR4386_b = ((void *) PR4386_foo) != 0; // expected-error{{initializer element is not a compile-time constant}} +int PR4386_c = ((void *) PR4386_zed) != 0; +int PR4386_zed() __attribute((weak)); + +// <rdar://problem/10185490> (derived from SPEC vortex benchmark) +typedef char strty[10]; +struct vortexstruct { strty s; }; +struct vortexstruct vortexvar = { "asdf" }; diff --git a/clang/test/Sema/initialize-noreturn.c b/clang/test/Sema/initialize-noreturn.c new file mode 100644 index 0000000..5557862 --- /dev/null +++ b/clang/test/Sema/initialize-noreturn.c @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify +// rdar://10095762 + +typedef void (*Fn_noret)(void) __attribute__((noreturn)); +typedef void (*Fn_ret)(void); + +void foo(void); +void foo_noret(void) __attribute__((noreturn)); + +void test() { + Fn_noret fn2 = &foo; // expected-warning {{incompatible pointer types initializing 'Fn_noret'}} + Fn_noret fn3 = &foo_noret; + Fn_ret fn4 = &foo_noret; + Fn_ret fn5 = &foo; +} + diff --git a/clang/test/Sema/inline-redef.c b/clang/test/Sema/inline-redef.c new file mode 100644 index 0000000..4a46e11 --- /dev/null +++ b/clang/test/Sema/inline-redef.c @@ -0,0 +1,24 @@ +// RUN: %clang_cc1 -std=gnu89 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify %s + +#if __STDC_VERSION__ >= 199901 +#define GNU_INLINE __attribute((__gnu_inline__)) +#else +#define GNU_INLINE +#endif + +// PR5253 +// rdar://9559708 (same extension in C99 mode) +// GNU Extension: check that we can redefine an extern inline function +GNU_INLINE extern inline int f(int a) {return a;} +int f(int b) {return b;} // expected-note{{previous definition is here}} +// And now check that we can't redefine a normal function +int f(int c) {return c;} // expected-error{{redefinition of 'f'}} + +// Check that we can redefine an extern inline function as a static function +GNU_INLINE extern inline int g(int a) {return a;} +static int g(int b) {return b;} + +// Check that we ensure the types of the two definitions are the same +GNU_INLINE extern inline int h(int a) {return a;} // expected-note{{previous definition is here}} +int h(short b) {return b;} // expected-error{{conflicting types for 'h'}} diff --git a/clang/test/Sema/inline.c b/clang/test/Sema/inline.c new file mode 100644 index 0000000..3c99f24 --- /dev/null +++ b/clang/test/Sema/inline.c @@ -0,0 +1,6 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// Check that we don't allow illegal uses of inline +inline int a; // expected-error{{'inline' can only appear on functions}} +typedef inline int b; // expected-error{{'inline' can only appear on functions}} +int d(inline int a); // expected-error{{'inline' can only appear on functions}} diff --git a/clang/test/Sema/int-arith-convert.c b/clang/test/Sema/int-arith-convert.c new file mode 100644 index 0000000..c56ab3b --- /dev/null +++ b/clang/test/Sema/int-arith-convert.c @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 -triple=i686-linux-gnu -fsyntax-only -verify %s + +// Check types are the same through redeclaration +unsigned long x; +__typeof(1u+1l) x; + +unsigned y; +__typeof(1+1u) y; +__typeof(1u+1) y; + +long long z; +__typeof(1ll+1u) z; diff --git a/clang/test/Sema/invalid-decl.c b/clang/test/Sema/invalid-decl.c new file mode 100644 index 0000000..a5e7ad3 --- /dev/null +++ b/clang/test/Sema/invalid-decl.c @@ -0,0 +1,22 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify + +void test() { + char = 4; // expected-error {{expected identifier}} +} + + +// PR2400 +typedef xtype (*x)(void* handle); // expected-error {{function cannot return function type}} expected-warning {{type specifier missing, defaults to 'int'}} expected-warning {{type specifier missing, defaults to 'int'}} + +typedef void ytype(); + + +typedef struct _zend_module_entry zend_module_entry; +struct _zend_module_entry { + ytype globals_size; // expected-error {{field 'globals_size' declared as a function}} +}; + +zend_module_entry openssl_module_entry = { + sizeof(zend_module_entry) +}; + diff --git a/clang/test/Sema/invalid-init-diag.c b/clang/test/Sema/invalid-init-diag.c new file mode 100644 index 0000000..3e4870e --- /dev/null +++ b/clang/test/Sema/invalid-init-diag.c @@ -0,0 +1,4 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only + +int a; +struct {int x;} x = a; // expected-error {{with an expression of incompatible type 'int'}} diff --git a/clang/test/Sema/invalid-struct-init.c b/clang/test/Sema/invalid-struct-init.c new file mode 100644 index 0000000..000d3ab --- /dev/null +++ b/clang/test/Sema/invalid-struct-init.c @@ -0,0 +1,27 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only + +typedef struct _zend_module_entry zend_module_entry; +struct _zend_module_entry { + _efree((p)); // expected-error{{type name requires a specifier or qualifier}} \ + expected-warning {{type specifier missing, defaults to 'int'}} + +}; +typedef struct _zend_function_entry { } zend_function_entry; +typedef struct _zend_pcre_globals { } zend_pcre_globals; +zend_pcre_globals pcre_globals; + +static void zm_globals_ctor_pcre(zend_pcre_globals *pcre_globals ) { } +static void zm_globals_dtor_pcre(zend_pcre_globals *pcre_globals ) { } +static void zm_info_pcre(zend_module_entry *zend_module ) { } +static int zm_startup_pcre(int type, int module_number ) { } + +static int zm_shutdown_pcre(int type, int module_number ) { + zend_function_entry pcre_functions[] = {{ }; // expected-error{{expected '}'}} expected-note {{to match this '{'}} + zend_module_entry pcre_module_entry = { + sizeof(zend_module_entry), 20071006, 0, 0, ((void *)0), ((void *)0), + "pcre", pcre_functions, zm_startup_pcre, zm_shutdown_pcre, ((void *)0), + ((void *)0), zm_info_pcre, ((void *)0), sizeof(zend_pcre_globals), &pcre_globals, + ((void (*)(void* ))(zm_globals_ctor_pcre)), ((void (*)(void* ))(zm_globals_dtor_pcre)), + ((void *)0), 0, 0, ((void *)0), 0 + }; +} diff --git a/clang/test/Sema/knr-def-call.c b/clang/test/Sema/knr-def-call.c new file mode 100644 index 0000000..f41275d --- /dev/null +++ b/clang/test/Sema/knr-def-call.c @@ -0,0 +1,41 @@ +// RUN: %clang_cc1 -Wconversion -Wliteral-conversion -fsyntax-only -verify %s + +// C DR #316, PR 3626. +void f0(a, b, c, d) int a,b,c,d; {} +void t0(void) { + f0(1); // expected-warning{{too few arguments}} +} + +void f1(a, b) int a, b; {} +void t1(void) { + f1(1, 2, 3); // expected-warning{{too many arguments}} +} + +void f2(float); // expected-note{{previous declaration is here}} +void f2(x) float x; { } // expected-warning{{promoted type 'double' of K&R function parameter is not compatible with the parameter type 'float' declared in a previous prototype}} + +typedef void (*f3)(void); +f3 t3(int b) { return b? f0 : f1; } // okay + +// <rdar://problem/8193107> +void f4() { + char *rindex(); +} + +char *rindex(s, c) + register char *s, c; // expected-warning{{promoted type 'char *' of K&R function parameter is not compatible with the parameter type 'const char *' declared in a previous prototype}} +{ + return 0; +} + +// PR8314 +void proto(int); +void proto(x) + int x; +{ +} + +void use_proto() { + proto(42.1); // expected-warning{{implicit conversion turns literal floating-point number into integer}} + (&proto)(42.1); // expected-warning{{implicit conversion turns literal floating-point number into integer}} +} diff --git a/clang/test/Sema/knr-variadic-def.c b/clang/test/Sema/knr-variadic-def.c new file mode 100644 index 0000000..6d5d632 --- /dev/null +++ b/clang/test/Sema/knr-variadic-def.c @@ -0,0 +1,29 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -pedantic %s +// PR4287 + +#include <stdarg.h> +char *foo = "test"; +int test(char*,...); + +int test(fmt) + char*fmt; +{ + va_list ap; + char*a; + int x; + + va_start(ap,fmt); + a=va_arg(ap,char*); + x=(a!=foo); + va_end(ap); + return x; +} + +void exit(); + +int main(argc,argv) + int argc;char**argv; +{ + exit(test("",foo)); +} + diff --git a/clang/test/Sema/many-logical-ops.c b/clang/test/Sema/many-logical-ops.c new file mode 100644 index 0000000..09a7684 --- /dev/null +++ b/clang/test/Sema/many-logical-ops.c @@ -0,0 +1,2010 @@ +// RUN: %clang_cc1 -fsyntax-only -Wconstant-conversion -verify %s + +// rdar://10913206&10941790 +// Check that we don't get stack overflow trying to evaluate a huge number of +// logical operators. + +int foo(int x) { + return + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x && + x; +} diff --git a/clang/test/Sema/many-parameters.c b/clang/test/Sema/many-parameters.c new file mode 100644 index 0000000..1473c94 --- /dev/null +++ b/clang/test/Sema/many-parameters.c @@ -0,0 +1,310 @@ +// RUN: %clang_cc1 -fsyntax-only -std=c99 %s + +// This test simply tests that the compiler does not crash. An optimization +// in ParmVarDecls means that functions with fewer than 256 parameters use a fast path, +// while those with >= 256 parameters use a slow path. +// +// Crash was reported in PR 10538. + +void foo( +int x0, +int x1, +int x2, +int x3, +int x4, +int x5, +int x6, +int x7, +int x8, +int x9, +int x10, +int x11, +int x12, +int x13, +int x14, +int x15, +int x16, +int x17, +int x18, +int x19, +int x20, +int x21, +int x22, +int x23, +int x24, +int x25, +int x26, +int x27, +int x28, +int x29, +int x30, +int x31, +int x32, +int x33, +int x34, +int x35, +int x36, +int x37, +int x38, +int x39, +int x40, +int x41, +int x42, +int x43, +int x44, +int x45, +int x46, +int x47, +int x48, +int x49, +int x50, +int x51, +int x52, +int x53, +int x54, +int x55, +int x56, +int x57, +int x58, +int x59, +int x60, +int x61, +int x62, +int x63, +int x64, +int x65, +int x66, +int x67, +int x68, +int x69, +int x70, +int x71, +int x72, +int x73, +int x74, +int x75, +int x76, +int x77, +int x78, +int x79, +int x80, +int x81, +int x82, +int x83, +int x84, +int x85, +int x86, +int x87, +int x88, +int x89, +int x90, +int x91, +int x92, +int x93, +int x94, +int x95, +int x96, +int x97, +int x98, +int x99, +int x100, +int x101, +int x102, +int x103, +int x104, +int x105, +int x106, +int x107, +int x108, +int x109, +int x110, +int x111, +int x112, +int x113, +int x114, +int x115, +int x116, +int x117, +int x118, +int x119, +int x120, +int x121, +int x122, +int x123, +int x124, +int x125, +int x126, +int x127, +int x128, +int x129, +int x130, +int x131, +int x132, +int x133, +int x134, +int x135, +int x136, +int x137, +int x138, +int x139, +int x140, +int x141, +int x142, +int x143, +int x144, +int x145, +int x146, +int x147, +int x148, +int x149, +int x150, +int x151, +int x152, +int x153, +int x154, +int x155, +int x156, +int x157, +int x158, +int x159, +int x160, +int x161, +int x162, +int x163, +int x164, +int x165, +int x166, +int x167, +int x168, +int x169, +int x170, +int x171, +int x172, +int x173, +int x174, +int x175, +int x176, +int x177, +int x178, +int x179, +int x180, +int x181, +int x182, +int x183, +int x184, +int x185, +int x186, +int x187, +int x188, +int x189, +int x190, +int x191, +int x192, +int x193, +int x194, +int x195, +int x196, +int x197, +int x198, +int x199, +int x200, +int x201, +int x202, +int x203, +int x204, +int x205, +int x206, +int x207, +int x208, +int x209, +int x210, +int x211, +int x212, +int x213, +int x214, +int x215, +int x216, +int x217, +int x218, +int x219, +int x220, +int x221, +int x222, +int x223, +int x224, +int x225, +int x226, +int x227, +int x228, +int x229, +int x230, +int x231, +int x232, +int x233, +int x234, +int x235, +int x236, +int x237, +int x238, +int x239, +int x240, +int x241, +int x242, +int x243, +int x244, +int x245, +int x246, +int x247, +int x248, +int x249, +int x250, +int x251, +int x252, +int x253, +int x254, +int x255, +int x256, +int x257, +int x258, +int x259, +int x260, +int x261, +int x262, +int x263, +int x264, +int x265, +int x266, +int x267, +int x268, +int x269, +int x270, +int x271, +int x272, +int x273, +int x274, +int x275, +int x276, +int x277, +int x278, +int x279, +int x280, +int x281, +int x282, +int x283, +int x284, +int x285, +int x286, +int x287, +int x288, +int x289, +int x290, +int x291, +int x292, +int x293, +int x294, +int x295, +int x296, +int x297, +int x298, +int x299 +); diff --git a/clang/test/Sema/member-reference.c b/clang/test/Sema/member-reference.c new file mode 100644 index 0000000..7bda143 --- /dev/null +++ b/clang/test/Sema/member-reference.c @@ -0,0 +1,20 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only + +struct simple { int i; }; + +void f(void) { + struct simple s[1]; + s->i = 1; +} + +typedef int x; +struct S { + int x; + x z; +}; + +void g(void) { + struct S s[1]; + s->x = 1; + s->z = 2; +} diff --git a/clang/test/Sema/memset-invalid.c b/clang/test/Sema/memset-invalid.c new file mode 100644 index 0000000..c763858 --- /dev/null +++ b/clang/test/Sema/memset-invalid.c @@ -0,0 +1,6 @@ +// RUN: %clang_cc1 -fsyntax-only %s -verify + +char memset(); // expected-warning {{incompatible redeclaration of library function 'memset'}} expected-note{{'memset' is a builtin with type}} +char test() { + return memset(); +} diff --git a/clang/test/Sema/merge-decls.c b/clang/test/Sema/merge-decls.c new file mode 100644 index 0000000..1a84d33 --- /dev/null +++ b/clang/test/Sema/merge-decls.c @@ -0,0 +1,39 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only + +void foo(void); +void foo(void) {} +void foo(void); +void foo(void); // expected-note {{previous declaration is here}} + +void foo(int); // expected-error {{conflicting types for 'foo'}} + +int funcdef() +{ + return 0; +} + +int funcdef(); + +int funcdef2() { return 0; } // expected-note {{previous definition is here}} +int funcdef2() { return 0; } // expected-error {{redefinition of 'funcdef2'}} + +// PR2502 +void (*f)(void); +void (*f)() = 0; + +typedef __attribute__(( ext_vector_type(2) )) int Vi2; +typedef __attribute__(( ext_vector_type(2) )) float Vf2; + +Vf2 g0; // expected-note {{previous definition is here}} +Vi2 g0; // expected-error {{redefinition of 'g0'}} + +_Complex int g1; // expected-note {{previous definition is here}} +_Complex float g1; // expected-error {{redefinition of 'g1'}} + +// rdar://6096412 +extern char i6096412[10]; +extern char i6096412[]; +void foo6096412(void) { + int x = sizeof(i6096412); +} + diff --git a/clang/test/Sema/missing-field-initializers.c b/clang/test/Sema/missing-field-initializers.c new file mode 100644 index 0000000..90e0e2a --- /dev/null +++ b/clang/test/Sema/missing-field-initializers.c @@ -0,0 +1,52 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wmissing-field-initializers %s + +// This was PR4808. + +struct Foo { int a, b; }; + +struct Foo foo0 = { 1 }; // expected-warning {{missing field 'b' initializer}} +struct Foo foo1 = { .a = 1 }; // designator avoids MFI warning +struct Foo foo2 = { .b = 1 }; // designator avoids MFI warning + +struct Foo bar0[] = { + { 1,2 }, + { 1 }, // expected-warning {{missing field 'b' initializer}} + { 1,2 } +}; + +struct Foo bar1[] = { + 1, 2, + 1, 2, + 1 +}; // expected-warning {{missing field 'b' initializer}} + +struct Foo bar2[] = { {}, {}, {} }; + +struct One { int a; int b; }; +struct Two { float c; float d; float e; }; + +struct Three { + union { + struct One one; + struct Two two; + } both; +}; + +struct Three t0 = { + { .one = { 1, 2 } } +}; +struct Three t1 = { + { .two = { 1.0f, 2.0f, 3.0f } } +}; + +struct Three data[] = { + { { .one = { 1, 2 } } }, + { { .one = { 1 } } }, // expected-warning {{missing field 'b' initializer}} + { { .two = { 1.0f, 2.0f, 3.0f } } }, + { { .two = { 1.0f, 2.0f } } } // expected-warning {{missing field 'e' initializer}} +}; + +struct { int:5; int a; int:5; int b; int:5; } noNamedImplicit[] = { + { 1, 2 }, + { 1 } // expected-warning {{missing field 'b' initializer}} +}; diff --git a/clang/test/Sema/ms_class_layout.cpp b/clang/test/Sema/ms_class_layout.cpp new file mode 100644 index 0000000..ea3f899 --- /dev/null +++ b/clang/test/Sema/ms_class_layout.cpp @@ -0,0 +1,335 @@ +// RUN: %clang_cc1 -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -cxx-abi microsoft %s 2>&1 \ +// RUN: | FileCheck %s + +#pragma pack(push, 8) + +class B { +public: + virtual void b(){} + int b_field; +protected: +private: +}; + +class A : public B { +public: + int a_field; + virtual void a(){} + char one; +protected: +private: +}; + +class D { +public: + virtual void b(){} + double a; +}; + +class C : public virtual A, + public D, public B { +public: + double c1_field; + int c2_field; + double c3_field; + int c4_field; + virtual void foo(){} + virtual void bar(){} +protected: +private: +}; + +struct BaseStruct +{ + BaseStruct(){} + double v0; + float v1; + C fg; +}; + +struct DerivedStruct : public BaseStruct { + int x; +}; + +struct G +{ + int g_field; +}; + +struct H : public G, + public virtual D +{ +}; + +struct I : public virtual D +{ + virtual ~I(){} + double q; +}; + +struct K +{ + int k; +}; + +struct L +{ + int l; +}; + +struct M : public virtual K +{ + int m; +}; + +struct N : public L, public M +{ + virtual void f(){} +}; + +struct O : public H, public G { + virtual void fo(){} +}; + +struct P : public M, public virtual L { + int p; +}; + +struct R {}; + +#pragma pack(pop) + +// This needs only for building layouts. +// Without this clang doesn`t dump record layouts. +int main() { + // This avoid "Can't yet mangle constructors!" for MS ABI. + C* c; + c->foo(); + DerivedStruct* v; + H* g; + BaseStruct* u; + I* i; + N* n; + O* o; + P* p; + R* r; + return 0; +} + +// CHECK: 0 | class D +// CHECK-NEXT: 0 | (D vftable pointer) +// CHECK-NEXT: 8 | double a + +// CHECK-NEXT: sizeof=16, dsize=16, align=8 +// CHECK-NEXT: nvsize=16, nvalign=8 + +// CHECK: %class.D = type { i32 (...)**, double } + +// CHECK: 0 | class B +// CHECK-NEXT: 0 | (B vftable pointer) +// CHECK-NEXT: 4 | int b_field + +// CHECK-NEXT: sizeof=8, dsize=8, align=4 +// CHECK-NEXT: nvsize=8, nvalign=4 + +// CHECK: %class.B = type { i32 (...)**, i32 } + +// CHECK: 0 | class A +// CHECK-NEXT: 0 | class B (primary base) +// CHECK-NEXT: 0 | (B vftable pointer) +// CHECK-NEXT: 4 | int b_field +// CHECK-NEXT: 8 | int a_field +// CHECK-NEXT: 12 | char one + +// CHECK-NEXT: sizeof=16, dsize=16, align=4 +// CHECK-NEXT: nvsize=16, nvalign=4 + +// CHECK: 0 | class C +// CHECK-NEXT: 0 | class D (primary base) +// CHECK-NEXT: 0 | (D vftable pointer) +// CHECK-NEXT: 8 | double a +// CHECK-NEXT: 16 | class B (base) +// CHECK-NEXT: 16 | (B vftable pointer) +// CHECK-NEXT: 20 | int b_field +// CHECK-NEXT: 24 | (C vbtable pointer) +// CHECK-NEXT: 32 | double c1_field +// CHECK-NEXT: 40 | int c2_field +// CHECK-NEXT: 48 | double c3_field +// CHECK-NEXT: 56 | int c4_field +// CHECK-NEXT: 64 | class A (virtual base) +// CHECK-NEXT: 64 | class B (primary base) +// CHECK-NEXT: 64 | (B vftable pointer) +// CHECK-NEXT: 68 | int b_field +// CHECK-NEXT: 72 | int a_field +// CHECK-NEXT: 76 | char one + +// CHECK-NEXT: sizeof=80, dsize=80, align=8 +// CHECK-NEXT: nvsize=64, nvalign=8 + +// CHECK: %class.A = type { %class.B, i32, i8 } + +// CHECK: %class.C = type { %class.D, %class.B, i32*, double, i32, double, i32, [4 x i8], %class.A } +// CHECK: %class.C.base = type { %class.D, %class.B, i32*, double, i32, double, i32 } + +// CHECK: 0 | struct BaseStruct +// CHECK-NEXT: 0 | double v0 +// CHECK-NEXT: 8 | float v1 +// CHECK-NEXT: 16 | class C fg +// CHECK-NEXT: 16 | class D (primary base) +// CHECK-NEXT: 16 | (D vftable pointer) +// CHECK-NEXT: 24 | double a +// CHECK-NEXT: 32 | class B (base) +// CHECK-NEXT: 32 | (B vftable pointer) +// CHECK-NEXT: 36 | int b_field +// CHECK-NEXT: 40 | (C vbtable pointer) +// CHECK-NEXT: 48 | double c1_field +// CHECK-NEXT: 56 | int c2_field +// CHECK-NEXT: 64 | double c3_field +// CHECK-NEXT: 72 | int c4_field +// CHECK-NEXT: 80 | class A (virtual base) +// CHECK-NEXT: 80 | class B (primary base) +// CHECK-NEXT: 80 | (B vftable pointer) +// CHECK-NEXT: 84 | int b_field +// CHECK-NEXT: 88 | int a_field +// CHECK-NEXT: 92 | char one + +// CHECK-NEXT: sizeof=80, dsize=80, align=8 +// CHECK-NEXT: nvsize=64, nvalign=8 + +// CHECK: sizeof=96, dsize=96, align=8 +// CHECK-NEXT: nvsize=96, nvalign=8 + +// CHECK: %struct.BaseStruct = type { double, float, %class.C } + +// CHECK: 0 | struct DerivedStruct +// CHECK-NEXT: 0 | struct BaseStruct (base) +// CHECK-NEXT: 0 | double v0 +// CHECK-NEXT: 8 | float v1 +// CHECK-NEXT: 16 | class C fg +// CHECK-NEXT: 16 | class D (primary base) +// CHECK-NEXT: 16 | (D vftable pointer) +// CHECK-NEXT: 24 | double a +// CHECK-NEXT: 32 | class B (base) +// CHECK-NEXT: 32 | (B vftable pointer) +// CHECK-NEXT: 36 | int b_field +// CHECK-NEXT: 40 | (C vbtable pointer) +// CHECK-NEXT: 48 | double c1_field +// CHECK-NEXT: 56 | int c2_field +// CHECK-NEXT: 64 | double c3_field +// CHECK-NEXT: 72 | int c4_field +// CHECK-NEXT: 80 | class A (virtual base) +// CHECK-NEXT: 80 | class B (primary base) +// CHECK-NEXT: 80 | (B vftable pointer) +// CHECK-NEXT: 84 | int b_field +// CHECK-NEXT: 88 | int a_field +// CHECK-NEXT: 92 | char one +// CHECK-NEXT: sizeof=80, dsize=80, align=8 +// CHECK-NEXT: nvsize=64, nvalign=8 + +// CHECK: 96 | int x +// CHECK-NEXT: sizeof=104, dsize=104, align=8 +// CHECK-NEXT: nvsize=104, nvalign=8 + +// CHECK: %struct.DerivedStruct = type { %struct.BaseStruct, i32 } + +// CHECK: 0 | struct G +// CHECK-NEXT: 0 | int g_field +// CHECK-NEXT: sizeof=4, dsize=4, align=4 +// CHECK-NEXT: nvsize=4, nvalign=4 + +// CHECK: 0 | struct H +// CHECK-NEXT: 0 | struct G (base) +// CHECK-NEXT: 0 | int g_field +// CHECK-NEXT: 4 | (H vbtable pointer) +// CHECK-NEXT: 8 | class D (virtual base) +// CHECK-NEXT: 8 | (D vftable pointer) +// CHECK-NEXT: 16 | double a +// CHECK-NEXT: sizeof=24, dsize=24, align=8 +// CHECK-NEXT: nvsize=8, nvalign=4 + +// CHECK: %struct.H = type { %struct.G, i32*, %class.D } + +// CHECK: 0 | struct I +// CHECK-NEXT: 0 | (I vftable pointer) +// CHECK-NEXT: 8 | (I vbtable pointer) +// CHECK-NEXT: 16 | double q +// CHECK-NEXT: 24 | class D (virtual base) +// CHECK-NEXT: 24 | (D vftable pointer) +// CHECK-NEXT: 32 | double a +// CHECK-NEXT: sizeof=40, dsize=40, align=8 +// CHECK-NEXT: nvsize=24, nvalign=8 + +// CHECK: %struct.I = type { i32 (...)**, [4 x i8], i32*, double, %class.D } +// CHECK: %struct.I.base = type { i32 (...)**, [4 x i8], i32*, double } + +// CHECK: 0 | struct L +// CHECK-NEXT: 0 | int l +// CHECK-NEXT: sizeof=4, dsize=4, align=4 +// CHECK-NEXT: nvsize=4, nvalign=4 + +// CHECK: 0 | struct K +// CHECK-NEXT: 0 | int k +// CHECK-NEXT: sizeof=4, dsize=4, align=4 +// CHECK-NEXT: nvsize=4, nvalign=4 + +// CHECK: 0 | struct M +// CHECK-NEXT: 0 | (M vbtable pointer) +// CHECK-NEXT: 4 | int m +// CHECK-NEXT: 8 | struct K (virtual base) +// CHECK-NEXT: 8 | int k +// CHECK-NEXT: sizeof=12, dsize=12, align=4 + +//CHECK: %struct.M = type { i32*, i32, %struct.K } +//CHECK: %struct.M.base = type { i32*, i32 } + +// CHECK: 0 | struct N +// CHECK-NEXT: 4 | struct L (base) +// CHECK-NEXT: 4 | int l +// CHECK-NEXT: 8 | struct M (base) +// CHECK-NEXT: 8 | (M vbtable pointer) +// CHECK-NEXT: 12 | int m +// CHECK-NEXT: 0 | (N vftable pointer) +// CHECK-NEXT: 16 | struct K (virtual base) +// CHECK-NEXT: 16 | int k +// CHECK-NEXT: sizeof=20, dsize=20, align=4 +// CHECK-NEXT: nvsize=16, nvalign=4 + +//CHECK: %struct.N = type { i32 (...)**, %struct.L, %struct.M.base, %struct.K } + +// FIXME: MSVC place struct H at offset 8. +// CHECK: 0 | struct O +// CHECK-NEXT: 4 | struct H (base) +// CHECK-NEXT: 4 | struct G (base) +// CHECK-NEXT: 4 | int g_field +// CHECK-NEXT: 8 | (H vbtable pointer) +// CHECK-NEXT: 12 | struct G (base) +// CHECK-NEXT: 12 | int g_field +// CHECK-NEXT: 0 | (O vftable pointer) +// CHECK-NEXT: 16 | class D (virtual base) +// CHECK-NEXT: 16 | (D vftable pointer) +// CHECK-NEXT: 24 | double a +// CHECK-NEXT: sizeof=32, dsize=32, align=8 +// CHECK-NEXT: nvsize=16, nvalign=4 + +//CHECK: %struct.O = type { i32 (...)**, %struct.H.base, %struct.G, %class.D } +//CHECK: %struct.O.base = type { i32 (...)**, %struct.H.base, %struct.G } + +// CHECK: 0 | struct P +// CHECK-NEXT: 0 | struct M (base) +// CHECK-NEXT: 0 | (M vbtable pointer) +// CHECK-NEXT: 4 | int m +// CHECK-NEXT: 8 | int p +// CHECK-NEXT: 12 | struct K (virtual base) +// CHECK-NEXT: 12 | int k +// CHECK-NEXT: 16 | struct L (virtual base) +// CHECK-NEXT: 16 | int l +// CHECK-NEXT: sizeof=20, dsize=20, align=4 +// CHECK-NEXT: nvsize=12, nvalign=4 + +//CHECK: %struct.P = type { %struct.M.base, i32, %struct.K, %struct.L } + +// CHECK: 0 | struct R (empty) +// CHECK-NEXT: sizeof=1, dsize=0, align=1 +// CHECK-NEXT: nvsize=0, nvalign=1 + +//CHECK: %struct.R = type { i8 } diff --git a/clang/test/Sema/neon-vector-types.c b/clang/test/Sema/neon-vector-types.c new file mode 100644 index 0000000..cbf0133 --- /dev/null +++ b/clang/test/Sema/neon-vector-types.c @@ -0,0 +1,33 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify + +typedef float float32_t; +typedef signed char poly8_t; +typedef short poly16_t; +typedef unsigned long long uint64_t; + +// Define some valid Neon types. +typedef __attribute__((neon_vector_type(2))) int int32x2_t; +typedef __attribute__((neon_vector_type(4))) int int32x4_t; +typedef __attribute__((neon_vector_type(1))) uint64_t uint64x1_t; +typedef __attribute__((neon_vector_type(2))) uint64_t uint64x2_t; +typedef __attribute__((neon_vector_type(2))) float32_t float32x2_t; +typedef __attribute__((neon_vector_type(4))) float32_t float32x4_t; +typedef __attribute__((neon_polyvector_type(16))) poly8_t poly8x16_t; +typedef __attribute__((neon_polyvector_type(8))) poly16_t poly16x8_t; + +// The attributes must have a single argument. +typedef __attribute__((neon_vector_type(2, 4))) int only_one_arg; // expected-error{{attribute takes one argument}} + +// The number of elements must be an ICE. +typedef __attribute__((neon_vector_type(2.0))) int non_int_width; // expected-error{{attribute requires integer constant}} + +// Only certain element types are allowed. +typedef __attribute__((neon_vector_type(2))) double double_elt; // expected-error{{invalid vector element type}} +typedef __attribute__((neon_vector_type(4))) void* ptr_elt; // expected-error{{invalid vector element type}} +typedef __attribute__((neon_polyvector_type(4))) float32_t bad_poly_elt; // expected-error{{invalid vector element type}} +struct aggr { signed char c; }; +typedef __attribute__((neon_vector_type(8))) struct aggr aggregate_elt; // expected-error{{invalid vector element type}} + +// The total vector size must be 64 or 128 bits. +typedef __attribute__((neon_vector_type(1))) int int32x1_t; // expected-error{{Neon vector size must be 64 or 128 bits}} +typedef __attribute__((neon_vector_type(3))) int int32x3_t; // expected-error{{Neon vector size must be 64 or 128 bits}} diff --git a/clang/test/Sema/nested-redef.c b/clang/test/Sema/nested-redef.c new file mode 100644 index 0000000..bbc4859 --- /dev/null +++ b/clang/test/Sema/nested-redef.c @@ -0,0 +1,22 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +struct X { // expected-note{{previous definition is here}} + struct X { } x; // expected-error{{nested redefinition of 'X'}} +}; + +struct Y { }; +void f(void) { + struct Y { }; // okay: this is a different Y +} + +struct T; +struct Z { + struct T { int x; } t; + struct U { int x; } u; +}; + +void f2(void) { + struct T t; + struct U u; +} + + diff --git a/clang/test/Sema/no-format-y2k-turnsoff-format.c b/clang/test/Sema/no-format-y2k-turnsoff-format.c new file mode 100644 index 0000000..b206ecd --- /dev/null +++ b/clang/test/Sema/no-format-y2k-turnsoff-format.c @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 -verify -fsyntax-only -Wformat -Wno-format-y2k +// rdar://9504680 + +void foo(const char *, ...) __attribute__((__format__ (__printf__, 1, 2))); + +void bar(unsigned int a) { + foo("%s", a); // expected-warning {{format specifies type 'char *' but the argument has type 'unsigned int'}} +} + diff --git a/clang/test/Sema/nonnull.c b/clang/test/Sema/nonnull.c new file mode 100644 index 0000000..cea8e3d --- /dev/null +++ b/clang/test/Sema/nonnull.c @@ -0,0 +1,21 @@ +// RUN: %clang_cc1 -fsyntax-only %s +// rdar://9584012 + +typedef struct { + char *str; +} Class; + +typedef union { + Class *object; +} Instance __attribute__((transparent_union)); + +__attribute__((nonnull(1))) void Class_init(Instance this, char *str) { + this.object->str = str; +} + +int main(void) { + Class *obj; + Class_init(0, "Hello World"); // expected-warning {{null passed to a callee which requires a non-null argument}} + Class_init(obj, "Hello World"); +} + diff --git a/clang/test/Sema/offsetof.c b/clang/test/Sema/offsetof.c new file mode 100644 index 0000000..46fb515 --- /dev/null +++ b/clang/test/Sema/offsetof.c @@ -0,0 +1,71 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +#define offsetof(TYPE, MEMBER) __builtin_offsetof (TYPE, MEMBER) + +typedef struct P { int i; float f; } PT; +struct external_sun3_core +{ + unsigned c_regs; + + PT X[100]; + +}; + +void swap() +{ + int x; + x = offsetof(struct external_sun3_core, c_regs); + x = __builtin_offsetof(struct external_sun3_core, X[42].f); + + x = __builtin_offsetof(struct external_sun3_core, X[42].f2); // expected-error {{no member named 'f2'}} + x = __builtin_offsetof(int, X[42].f2); // expected-error {{offsetof requires struct}} + + int a[__builtin_offsetof(struct external_sun3_core, X) == 4 ? 1 : -1]; + int b[__builtin_offsetof(struct external_sun3_core, X[42]) == 340 ? 1 : -1]; + int c[__builtin_offsetof(struct external_sun3_core, X[42].f2) == 344 ? 1 : -1]; // expected-error {{no member named 'f2'}} +} + +extern int f(); + +struct s1 { int a; }; +int v1 = offsetof (struct s1, a) == 0 ? 0 : f(); + +struct s2 { int a; }; +int v2 = (int)(&((struct s2 *) 0)->a) == 0 ? 0 : f(); + +struct s3 { int a; }; +int v3 = __builtin_offsetof(struct s3, a) == 0 ? 0 : f(); + +// PR3396 +struct sockaddr_un { + unsigned char sun_len; + char sun_path[104]; +}; +int a(int len) { +int a[__builtin_offsetof(struct sockaddr_un, sun_path[len+1])]; +} + +// PR4079 +union x {struct {int x;};}; +int x[__builtin_offsetof(union x, x)]; + +// rdar://problem/7222956 +struct incomplete; // expected-note 2 {{forward declaration of 'struct incomplete'}} +int test1[__builtin_offsetof(struct incomplete, foo)]; // expected-error {{offsetof of incomplete type 'struct incomplete'}} + +int test2[__builtin_offsetof(struct incomplete[10], [4].foo)]; // expected-error {{array has incomplete element type 'struct incomplete'}} + +// Bitfields +struct has_bitfields { + int i : 7; + int j : 12; // expected-note{{bit-field is declared here}} +}; + +int test3 = __builtin_offsetof(struct has_bitfields, j); // expected-error{{cannot compute offset of bit-field 'j'}} + +typedef struct Array { int array[1]; } Array; +int test4 = __builtin_offsetof(Array, array); + +int test5() { + return __builtin_offsetof(Array, array[*(int*)0]); // expected-warning{{indirection of non-volatile null pointer}} expected-note{{__builtin_trap}} +} diff --git a/clang/test/Sema/overloadable-complex.c b/clang/test/Sema/overloadable-complex.c new file mode 100644 index 0000000..efdeb8f --- /dev/null +++ b/clang/test/Sema/overloadable-complex.c @@ -0,0 +1,50 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +char *foo(float) __attribute__((__overloadable__)); + +void test_foo_1(float fv, double dv, float _Complex fc, double _Complex dc) { + char *cp1 = foo(fv); + char *cp2 = foo(dv); + // Note: GCC and EDG reject these two, but they are valid C99 conversions + char *cp3 = foo(fc); + char *cp4 = foo(dc); +} + +int *foo(float _Complex) __attribute__((__overloadable__)); + +void test_foo_2(float fv, double dv, float _Complex fc, double _Complex dc) { + char *cp1 = foo(fv); + char *cp2 = foo(dv); + int *ip = foo(fc); + int *lp = foo(dc); +} + +long *foo(double _Complex) __attribute__((__overloadable__)); + +void test_foo_3(float fv, double dv, float _Complex fc, double _Complex dc) { + char *cp1 = foo(fv); + char *cp2 = foo(dv); + int *ip = foo(fc); + long *lp = foo(dc); +} + +char *promote_or_convert(double _Complex) __attribute__((__overloadable__)); // expected-note 2 {{candidate function}} +int *promote_or_convert(long double _Complex) __attribute__((__overloadable__)); // expected-note 2 {{candidate function}} + +void test_promote_or_convert(float f, float _Complex fc) { + char *cp = promote_or_convert(fc); // expected-error{{call to 'promote_or_convert' is ambiguous}} + int *ip2 = promote_or_convert(f); // expected-error{{call to 'promote_or_convert' is ambiguous}} +} + +char *promote_or_convert2(float) __attribute__((__overloadable__)); +int *promote_or_convert2(double _Complex) __attribute__((__overloadable__)); + +void test_promote_or_convert2(float _Complex fc) { + int *cp = promote_or_convert2(fc); +} + +char *promote_or_convert3(int _Complex) __attribute__((__overloadable__)); +int *promote_or_convert3(long _Complex) __attribute__((__overloadable__)); + +void test_promote_or_convert3(short _Complex sc) { + char *cp = promote_or_convert3(sc); +} diff --git a/clang/test/Sema/overloadable.c b/clang/test/Sema/overloadable.c new file mode 100644 index 0000000..5d39f15 --- /dev/null +++ b/clang/test/Sema/overloadable.c @@ -0,0 +1,71 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +int var __attribute__((overloadable)); // expected-error{{'overloadable' attribute can only be applied to a function}} + +int *f(int) __attribute__((overloadable)); // expected-note 2{{previous overload of function is here}} +float *f(float); // expected-error{{overloaded function 'f' must have the 'overloadable' attribute}} +int *f(int); // expected-error{{redeclaration of 'f' must have the 'overloadable' attribute}} \ + // expected-note{{previous declaration is here}} +double *f(double) __attribute__((overloadable)); // okay, new + +void test_f(int iv, float fv, double dv) { + int *ip = f(iv); + float *fp = f(fv); + double *dp = f(dv); +} + +int *accept_funcptr(int (*)()) __attribute__((overloadable)); // \ + // expected-note{{candidate function}} +float *accept_funcptr(int (*)(int, double)) __attribute__((overloadable)); // \ + // expected-note{{candidate function}} + +void test_funcptr(int (*f1)(int, double), + int (*f2)(int, float)) { + float *fp = accept_funcptr(f1); + accept_funcptr(f2); // expected-error{{no matching function for call to 'accept_funcptr'}} +} + +struct X { int x; float y; }; +struct Y { int x; float y; }; +int* accept_struct(struct X x) __attribute__((__overloadable__)); +float* accept_struct(struct Y y) __attribute__((overloadable)); + +void test_struct(struct X x, struct Y y) { + int *ip = accept_struct(x); + float *fp = accept_struct(y); +} + +double *f(int) __attribute__((overloadable)); // expected-error{{conflicting types for 'f'}} + +double promote(float) __attribute__((__overloadable__)); // expected-note {{candidate}} +double promote(double) __attribute__((__overloadable__)); // expected-note {{candidate}} +long double promote(long double) __attribute__((__overloadable__)); // expected-note {{candidate}} + +void promote(...) __attribute__((__overloadable__, __unavailable__)); // \ + // expected-note{{candidate function}} + +void test_promote(short* sp) { + promote(1.0); + promote(sp); // expected-error{{call to unavailable function 'promote'}} +} + +// PR6600 +typedef double Double; +typedef Double DoubleVec __attribute__((vector_size(16))); +typedef int Int; +typedef Int IntVec __attribute__((vector_size(16))); +double magnitude(DoubleVec) __attribute__((__overloadable__)); +double magnitude(IntVec) __attribute__((__overloadable__)); +double test_p6600(DoubleVec d) { + return magnitude(d) * magnitude(d); +} + +// PR7738 +extern int __attribute__((overloadable)) f0(); // expected-error{{'overloadable' function 'f0' must have a prototype}} +typedef int f1_type(); +f1_type __attribute__((overloadable)) f1; // expected-error{{'overloadable' function 'f1' must have a prototype}} + +void test() { + f0(); + f1(); +} diff --git a/clang/test/Sema/overloaded-func-transparent-union.c b/clang/test/Sema/overloaded-func-transparent-union.c new file mode 100644 index 0000000..fa0314e --- /dev/null +++ b/clang/test/Sema/overloaded-func-transparent-union.c @@ -0,0 +1,28 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify +// rdar:// 9129552 +// PR9406 + +typedef struct { + char *str; + char *str2; +} Class; + +typedef union { + Class *object; +} Instance __attribute__((transparent_union)); + +__attribute__((overloadable)) void Class_Init(Instance this, char *str, void *str2) { + this.object->str = str; + this.object->str2 = str2; +} + +__attribute__((overloadable)) void Class_Init(Instance this, char *str) { + this.object->str = str; + this.object->str2 = str; +} + +int main(void) { + Class obj; + Class_Init(&obj, "Hello ", " World"); +} + diff --git a/clang/test/Sema/parentheses.c b/clang/test/Sema/parentheses.c new file mode 100644 index 0000000..9751336 --- /dev/null +++ b/clang/test/Sema/parentheses.c @@ -0,0 +1,73 @@ +// RUN: %clang_cc1 -Wparentheses -fsyntax-only -verify %s +// RUN: %clang_cc1 -Wparentheses -fixit %s -o - | %clang_cc1 -Wparentheses -Werror - + +// Test the various warnings under -Wparentheses +void if_assign(void) { + int i; + if (i = 4) {} // expected-warning {{assignment as a condition}} \ + // expected-note{{use '==' to turn this assignment into an equality comparison}} \ + // expected-note{{place parentheses around the assignment to silence this warning}} + if ((i = 4)) {} +} + +void bitwise_rel(unsigned i) { + (void)(i & 0x2 == 0); // expected-warning {{& has lower precedence than ==}} \ + // expected-note{{place parentheses around the & expression to evaluate it first}} \ + // expected-note{{place parentheses around the == expression to silence this warning}} + (void)(0 == i & 0x2); // expected-warning {{& has lower precedence than ==}} \ + // expected-note{{place parentheses around the & expression to evaluate it first}} \ + // expected-note{{place parentheses around the == expression to silence this warning}} + (void)(i & 0xff < 30); // expected-warning {{& has lower precedence than <}} \ + // expected-note{{place parentheses around the & expression to evaluate it first}} \ + // expected-note{{place parentheses around the < expression to silence this warning}} + (void)((i & 0x2) == 0); + (void)(i & (0x2 == 0)); + // Eager logical op + (void)(i == 1 | i == 2 | i == 3); + (void)(i != 1 & i != 2 & i != 3); + + (void)(i & i | i); // expected-warning {{'&' within '|'}} \ + // expected-note {{place parentheses around the '&' expression to silence this warning}} + + (void)(i | i & i); // expected-warning {{'&' within '|'}} \ + // expected-note {{place parentheses around the '&' expression to silence this warning}} + + (void)(i || + i && i); // expected-warning {{'&&' within '||'}} \ + // expected-note {{place parentheses around the '&&' expression to silence this warning}} + (void)(i || i && "w00t"); // no warning. + (void)("w00t" && i || i); // no warning. + (void)(i || i && "w00t" || i); // expected-warning {{'&&' within '||'}} \ + // expected-note {{place parentheses around the '&&' expression to silence this warning}} + (void)(i || "w00t" && i || i); // expected-warning {{'&&' within '||'}} \ + // expected-note {{place parentheses around the '&&' expression to silence this warning}} + (void)(i && i || 0); // no warning. + (void)(0 || i && i); // no warning. +} + +_Bool someConditionFunc(); + +void conditional_op(int x, int y, _Bool b) { + (void)(x + someConditionFunc() ? 1 : 2); // expected-warning {{operator '?:' has lower precedence than '+'}} \ + // expected-note {{place parentheses around the '?:' expression to evaluate it first}} \ + // expected-note {{place parentheses around the '+' expression to silence this warning}} + + (void)((x + someConditionFunc()) ? 1 : 2); // no warning + + (void)(x - b ? 1 : 2); // expected-warning {{operator '?:' has lower precedence than '-'}} \ + // expected-note {{place parentheses around the '?:' expression to evaluate it first}} \ + // expected-note {{place parentheses around the '-' expression to silence this warning}} + + (void)(x * (x == y) ? 1 : 2); // expected-warning {{operator '?:' has lower precedence than '*'}} \ + // expected-note {{place parentheses around the '?:' expression to evaluate it first}} \ + // expected-note {{place parentheses around the '*' expression to silence this warning}} + + (void)(x / !x ? 1 : 2); // expected-warning {{operator '?:' has lower precedence than '/'}} \ + // expected-note {{place parentheses around the '?:' expression to evaluate it first}} \ + // expected-note {{place parentheses around the '/' expression to silence this warning}} + + (void)(x % 2 ? 1 : 2); // no warning +} + +// RUN: %clang_cc1 -fsyntax-only -Wparentheses -Werror -fdiagnostics-show-option %s 2>&1 | FileCheck %s +// CHECK: error: using the result of an assignment as a condition without parentheses [-Werror,-Wparentheses] diff --git a/clang/test/Sema/parentheses.cpp b/clang/test/Sema/parentheses.cpp new file mode 100644 index 0000000..7674166 --- /dev/null +++ b/clang/test/Sema/parentheses.cpp @@ -0,0 +1,47 @@ +// RUN: %clang_cc1 -Wparentheses -fsyntax-only -verify %s +// RUN: %clang_cc1 -Wparentheses -fixit %s -o - | %clang_cc1 -Wparentheses -Werror - + +bool someConditionFunc(); + +void conditional_op(int x, int y, bool b) { + (void)(x + someConditionFunc() ? 1 : 2); // expected-warning {{operator '?:' has lower precedence than '+'}} \ + // expected-note {{place parentheses around the '?:' expression to evaluate it first}} \ + // expected-note {{place parentheses around the '+' expression to silence this warning}} + + (void)(x - b ? 1 : 2); // expected-warning {{operator '?:' has lower precedence than '-'}} \ + // expected-note {{place parentheses around the '?:' expression to evaluate it first}} \ + // expected-note {{place parentheses around the '-' expression to silence this warning}} + + (void)(x * (x == y) ? 1 : 2); // expected-warning {{operator '?:' has lower precedence than '*'}} \ + // expected-note {{place parentheses around the '?:' expression to evaluate it first}} \ + // expected-note {{place parentheses around the '*' expression to silence this warning}} +} + +class Stream { +public: + operator int(); + Stream &operator<<(int); + Stream &operator<<(const char*); +}; + +void f(Stream& s, bool b) { + (void)(s << b ? "foo" : "bar"); // expected-warning {{operator '?:' has lower precedence than '<<'}} \ + // expected-note {{place parentheses around the '?:' expression to evaluate it first}} \ + // expected-note {{place parentheses around the '<<' expression to silence this warning}} +} + +struct S { + operator int() { return 42; } + friend S operator+(const S &lhs, bool) { return S(); } +}; + +void test(S *s, bool (S::*m_ptr)()) { + (void)(*s + true ? "foo" : "bar"); // expected-warning {{operator '?:' has lower precedence than '+'}} \ + // expected-note {{place parentheses around the '?:' expression to evaluate it first}} \ + // expected-note {{place parentheses around the '+' expression to silence this warning}} + + (void)((*s + true) ? "foo" : "bar"); // No warning. + + // Don't crash on unusual member call expressions. + (void)((s->*m_ptr)() ? "foo" : "bar"); +} diff --git a/clang/test/Sema/pointer-addition.c b/clang/test/Sema/pointer-addition.c new file mode 100644 index 0000000..21ce63b --- /dev/null +++ b/clang/test/Sema/pointer-addition.c @@ -0,0 +1,21 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify -pedantic + +typedef struct S S; // expected-note 3 {{forward declaration of 'struct S'}} +void a(S* b, void* c) { + void (*fp)(int) = 0; + b++; // expected-error {{arithmetic on a pointer to an incomplete type}} + b += 1; // expected-error {{arithmetic on a pointer to an incomplete type}} + c++; // expected-warning {{arithmetic on a pointer to void is a GNU extension}} + c += 1; // expected-warning {{arithmetic on a pointer to void is a GNU extension}} + c--; // expected-warning {{arithmetic on a pointer to void is a GNU extension}} + c -= 1; // expected-warning {{arithmetic on a pointer to void is a GNU extension}} + (void) c[1]; // expected-warning {{subscript of a pointer to void is a GNU extension}} + b = 1+b; // expected-error {{arithmetic on a pointer to an incomplete type}} + /* The next couple tests are only pedantic warnings in gcc */ + void (*d)(S*,void*) = a; + d += 1; // expected-warning {{arithmetic on a pointer to the function type 'void (S *, void *)' is a GNU extension}} + d++; // expected-warning {{arithmetic on a pointer to the function type 'void (S *, void *)' is a GNU extension}} + d--; // expected-warning {{arithmetic on a pointer to the function type 'void (S *, void *)' is a GNU extension}} + d -= 1; // expected-warning {{arithmetic on a pointer to the function type 'void (S *, void *)' is a GNU extension}} + (void)(1 + d); // expected-warning {{arithmetic on a pointer to the function type 'void (S *, void *)' is a GNU extension}} +} diff --git a/clang/test/Sema/pointer-conversion.c b/clang/test/Sema/pointer-conversion.c new file mode 100644 index 0000000..2d755ae --- /dev/null +++ b/clang/test/Sema/pointer-conversion.c @@ -0,0 +1,10 @@ +//RUN: %clang_cc1 -fsyntax-only -verify %s + +char * c; +char const ** c2 = &c; // expected-warning {{discards qualifiers in nested pointer types}} + +typedef char dchar; +dchar *** c3 = &c2; // expected-warning {{discards qualifiers in nested pointer types}} + +volatile char * c4; +char ** c5 = &c4; // expected-warning {{discards qualifiers in nested pointer types}} diff --git a/clang/test/Sema/pointer-subtract-compat.c b/clang/test/Sema/pointer-subtract-compat.c new file mode 100644 index 0000000..b801f81 --- /dev/null +++ b/clang/test/Sema/pointer-subtract-compat.c @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify -pedantic + +typedef const char rchar; +int a(char* a, rchar* b) { + return a-b; +} + +// <rdar://problem/6520707> +void f0(void (*fp)(void)) { + int x = fp - fp; // expected-warning{{arithmetic on pointers to the function type 'void (void)' is a GNU extension}} +} diff --git a/clang/test/Sema/pragma-align-mac68k-unsupported.c b/clang/test/Sema/pragma-align-mac68k-unsupported.c new file mode 100644 index 0000000..c23c01b --- /dev/null +++ b/clang/test/Sema/pragma-align-mac68k-unsupported.c @@ -0,0 +1,4 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify %s +// RUN: %clang_cc1 -triple i386-pc-linux-gnu -fsyntax-only -verify %s + +/* expected-error {{mac68k alignment pragma is not supported}} */ #pragma options align=mac68k diff --git a/clang/test/Sema/pragma-align-mac68k.c b/clang/test/Sema/pragma-align-mac68k.c new file mode 100644 index 0000000..fb8da51 --- /dev/null +++ b/clang/test/Sema/pragma-align-mac68k.c @@ -0,0 +1,98 @@ +// RUN: %clang_cc1 -triple i386-apple-darwin9 -fsyntax-only -verify %s + +#include <stddef.h> + +#pragma options align=mac68k + +typedef float __attribute__((vector_size (8))) v2f_t; +typedef float __attribute__((vector_size (16))) v4f_t; + +extern int a0_0[__alignof(v2f_t) == 8 ? 1 : -1]; +extern int a0_1[__alignof(v4f_t) == 16 ? 1 : -1]; + +struct s1 { + char f0; + int f1; +}; +extern int a1_0[offsetof(struct s1, f0) == 0 ? 1 : -1]; +extern int a1_1[offsetof(struct s1, f1) == 2 ? 1 : -1]; +extern int a1_2[sizeof(struct s1) == 6 ? 1 : -1]; +extern int a1_3[__alignof(struct s1) == 2 ? 1 : -1]; + +struct s2 { + char f0; + double f1; +}; +extern int a2_0[offsetof(struct s2, f0) == 0 ? 1 : -1]; +extern int a2_1[offsetof(struct s2, f1) == 2 ? 1 : -1]; +extern int a2_2[sizeof(struct s2) == 10 ? 1 : -1]; +extern int a2_3[__alignof(struct s2) == 2 ? 1 : -1]; + +struct s3 { + char f0; + v4f_t f1; +}; +extern int a3_0[offsetof(struct s3, f0) == 0 ? 1 : -1]; +extern int a3_1[offsetof(struct s3, f1) == 2 ? 1 : -1]; +extern int a3_2[sizeof(struct s3) == 18 ? 1 : -1]; +extern int a3_3[__alignof(struct s3) == 2 ? 1 : -1]; + +struct s4 { + char f0; + char f1; +}; +extern int a4_0[offsetof(struct s4, f0) == 0 ? 1 : -1]; +extern int a4_1[offsetof(struct s4, f1) == 1 ? 1 : -1]; +extern int a4_2[sizeof(struct s4) == 2 ? 1 : -1]; +extern int a4_3[__alignof(struct s4) == 2 ? 1 : -1]; + +struct s5 { + unsigned f0 : 9; + unsigned f1 : 9; +}; +extern int a5_0[sizeof(struct s5) == 4 ? 1 : -1]; +extern int a5_1[__alignof(struct s5) == 2 ? 1 : -1]; + +struct s6 { + unsigned : 0; + unsigned : 0; +}; +extern int a6_0[sizeof(struct s6) == 0 ? 1 : -1]; +extern int a6_1[__alignof(struct s6) == 2 ? 1 : -1]; + +struct s7 { + char : 1; + unsigned : 1; +}; +extern int a7_0[sizeof(struct s7) == 2 ? 1 : -1]; +extern int a7_1[__alignof(struct s7) == 2 ? 1 : -1]; + +struct s8 { + char f0; + unsigned : 1; +}; +extern int a8_0[sizeof(struct s8) == 2 ? 1 : -1]; +extern int a8_1[__alignof(struct s8) == 2 ? 1 : -1]; + +struct s9 { + char f0[3]; + unsigned : 0; + char f1; +}; +extern int a9_0[sizeof(struct s9) == 6 ? 1 : -1]; +extern int a9_1[__alignof(struct s9) == 2 ? 1 : -1]; + +struct s10 { + char f0; +}; +extern int a10_0[sizeof(struct s10) == 2 ? 1 : -1]; +extern int a10_1[__alignof(struct s10) == 2 ? 1 : -1]; + +struct s11 { + char f0; + v2f_t f1; +}; +extern int a11_0[offsetof(struct s11, f0) == 0 ? 1 : -1]; +extern int a11_1[offsetof(struct s11, f1) == 2 ? 1 : -1]; +extern int a11_2[sizeof(struct s11) == 10 ? 1 : -1]; +extern int a11_3[__alignof(struct s11) == 2 ? 1 : -1]; diff --git a/clang/test/Sema/pragma-align-packed.c b/clang/test/Sema/pragma-align-packed.c new file mode 100644 index 0000000..74fbd13 --- /dev/null +++ b/clang/test/Sema/pragma-align-packed.c @@ -0,0 +1,30 @@ +// RUN: %clang_cc1 -triple i386-apple-darwin9 -fsyntax-only -verify %s + +#pragma pack(push, 1) +struct s0 { + char f0; + int f1 __attribute__((aligned(4))); +}; +extern int a[sizeof(struct s0) == 5 ? 1 : -1]; +#pragma pack(pop) + +struct __attribute__((packed)) s1 { + char f0; + int f1 __attribute__((aligned(4))); +}; +extern int a[sizeof(struct s1) == 8 ? 1 : -1]; + +#pragma options align=packed +struct s2 { + char f0; + int f1 __attribute__((aligned(4))); +}; +extern int a[sizeof(struct s2) == 5 ? 1 : -1]; +#pragma options align=reset + +#pragma pack(1) +struct s3_0 { unsigned char f0; unsigned int f1; }; +int t3_0[sizeof(struct s3_0) == 5 ? 1 : -1]; +#pragma options align=reset +struct s3_1 { unsigned char f0; unsigned int f1; }; +int t3_1[sizeof(struct s3_1) == 8 ? 1 : -1]; diff --git a/clang/test/Sema/pragma-arc-cf-code-audited.c b/clang/test/Sema/pragma-arc-cf-code-audited.c new file mode 100644 index 0000000..b646e89 --- /dev/null +++ b/clang/test/Sema/pragma-arc-cf-code-audited.c @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +#pragma clang arc_cf_code_audited foo // expected-error {{expected 'begin' or 'end'}} + +#pragma clang arc_cf_code_audited begin foo // expected-warning {{extra tokens at end of #pragma directive}} + +#pragma clang arc_cf_code_audited end +#pragma clang arc_cf_code_audited end // expected-error {{not currently inside '#pragma clang arc_cf_code_audited'}} + +#pragma clang arc_cf_code_audited begin // expected-note {{#pragma entered here}} +#pragma clang arc_cf_code_audited begin // expected-error {{already inside '#pragma clang arc_cf_code_audited'}} expected-note {{#pragma entered here}} + +#include "Inputs/pragma-arc-cf-code-audited.h" // expected-error {{cannot #include files inside '#pragma clang arc_cf_code_audited'}} + +// This is actually on the #pragma line in the header. +// expected-error {{'#pragma clang arc_cf_code_audited' was not ended within this file}} + +#pragma clang arc_cf_code_audited begin // expected-error {{'#pragma clang arc_cf_code_audited' was not ended within this file}} diff --git a/clang/test/Sema/pragma-ms_struct.c b/clang/test/Sema/pragma-ms_struct.c new file mode 100644 index 0000000..d76ee8b --- /dev/null +++ b/clang/test/Sema/pragma-ms_struct.c @@ -0,0 +1,55 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-apple-darwin9 %s + +#pragma ms_struct on + +#pragma ms_struct off + +#pragma ms_struct reset + +#pragma ms_struct // expected-warning {{incorrect use of '#pragma ms_struct on|off' - ignored}} + +#pragma ms_struct on top of spaghetti // expected-warning {{extra tokens at end of '#pragma ms_struct' - ignored}} + +struct foo +{ + int a; + int b; + char c; +}; + + +struct { + unsigned long bf_1 : 12; + unsigned long : 0; + unsigned long bf_2 : 12; +} __attribute__((__ms_struct__)) t1; + +struct S { + double __attribute__((ms_struct)) d; // expected-warning {{'ms_struct' attribute ignored}} + unsigned long bf_1 : 12; + unsigned long : 0; + unsigned long bf_2 : 12; +} __attribute__((ms_struct)) t2; + + +// rdar://10513599 +#pragma ms_struct on + +typedef struct +{ +void *pv; +int l; +} Foo; + +typedef struct +{ +void *pv1; +Foo foo; +unsigned short fInited : 1; +void *pv2; +} PackOddity; + +#pragma ms_struct off + +static int arr[sizeof(PackOddity) == 40 ? 1 : -1]; + diff --git a/clang/test/Sema/pragma-pack-2.c b/clang/test/Sema/pragma-pack-2.c new file mode 100644 index 0000000..4a4c202 --- /dev/null +++ b/clang/test/Sema/pragma-pack-2.c @@ -0,0 +1,59 @@ +// RUN: %clang_cc1 -triple i686-apple-darwin9 %s -fsyntax-only -verify + +#include <stddef.h> + +#pragma pack(4) + +// Baseline +struct s0 { + char f0; + int f1; +}; +extern int a0[offsetof(struct s0, f1) == 4 ? 1 : -1]; + +#pragma pack(push, 2) +struct s1 { + char f0; + int f1; +}; +extern int a1[offsetof(struct s1, f1) == 2 ? 1 : -1]; +#pragma pack(pop) + +#pragma pack(1) +struct s3_0 { + char f0; + int f1; +}; +#pragma pack() +struct s3_1 { + char f0; + int f1; +}; +extern int a3_0[offsetof(struct s3_0, f1) == 1 ? 1 : -1]; +extern int a3_1[offsetof(struct s3_1, f1) == 4 ? 1 : -1]; + +// pack(0) is like pack() +#pragma pack(1) +struct s4_0 { + char f0; + int f1; +}; +#pragma pack(0) +struct s4_1 { + char f0; + int f1; +}; +extern int a4_0[offsetof(struct s4_0, f1) == 1 ? 1 : -1]; +extern int a4_1[offsetof(struct s4_1, f1) == 4 ? 1 : -1]; + +void f() { + #pragma pack(push, 2) + struct s5_0 { + char f0; + struct s2_4_0 { + int f0; + } f1; + }; + #pragma pack(pop) + extern int s5_0[offsetof(struct s5_0, f1) == 2 ? 1 : -1]; +} diff --git a/clang/test/Sema/pragma-pack-3.c b/clang/test/Sema/pragma-pack-3.c new file mode 100644 index 0000000..d97359e --- /dev/null +++ b/clang/test/Sema/pragma-pack-3.c @@ -0,0 +1,34 @@ +// RUN: %clang_cc1 -triple i686-apple-darwin9 %s -fsyntax-only -verify + +// Stack: [], Alignment: 8 + +#pragma pack(push, 1) +// Stack: [8], Alignment: 1 + +#pragma pack(push, 4) +// Stack: [8, 1], Alignment: 4 + +// Note that this differs from gcc; pack() in gcc appears to pop the +// top stack entry and resets the current alignment. This is both +// inconsistent with MSVC, and the gcc documentation. In other cases, +// for example changing this to pack(8), I don't even understand what gcc +// is doing. + +#pragma pack() +// Stack: [8, 1], Alignment: 8 + +#pragma pack(pop) +// Stack: [8], Alignment: 1 +struct s0 { + char f0; + short f1; +}; +int a[sizeof(struct s0) == 3 ? 1 : -1]; + +#pragma pack(pop) +// Stack: [], Alignment: 8 +struct s1 { + char f0; + short f1; +}; +int b[sizeof(struct s1) == 4 ? 1 : -1]; diff --git a/clang/test/Sema/pragma-pack-4.c b/clang/test/Sema/pragma-pack-4.c new file mode 100644 index 0000000..b06fc0e --- /dev/null +++ b/clang/test/Sema/pragma-pack-4.c @@ -0,0 +1,19 @@ +// RUN: %clang_cc1 -triple i686-apple-darwin9 %s -fsyntax-only -verify +// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -fsyntax-only -verify + +// rdar://problem/7095436 +#pragma pack(4) + +struct s0 { + long long a __attribute__((aligned(8))); + long long b __attribute__((aligned(8))); + unsigned int c __attribute__((aligned(8))); + int d[12]; +}; + +struct s1 { + int a[15]; + struct s0 b; +}; + +int arr0[((sizeof(struct s1) % 64) == 0) ? 1 : -1]; diff --git a/clang/test/Sema/pragma-pack-5.c b/clang/test/Sema/pragma-pack-5.c new file mode 100644 index 0000000..95bbe1f --- /dev/null +++ b/clang/test/Sema/pragma-pack-5.c @@ -0,0 +1,45 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -fsyntax-only -verify -ffreestanding +// <rdar://problem/10494810> and PR9560 +// Check #pragma pack handling with bitfields. + +#include <stddef.h> +#pragma pack(2) + +struct s0 { + char f1; + unsigned f2 : 32; + char f3; +}; +extern int check[sizeof(struct s0) == 6 ? 1 : -1]; + +struct s1 { + char f1; + unsigned : 0; + char f3; +}; +extern int check[sizeof(struct s1) == 5 ? 1 : -1]; + +struct s2 { + char f1; + unsigned : 0; + unsigned f3 : 8; + char f4; +}; +extern int check[sizeof(struct s2) == 6 ? 1 : -1]; + +struct s3 { + char f1; + unsigned : 0; + unsigned f3 : 16; + char f4; +}; +extern int check[sizeof(struct s3) == 8 ? 1 : -1]; +extern int check[offsetof(struct s3, f4) == 6 ? 1 : -1]; + +struct s4 { + char f1; + unsigned f2 : 8; + char f3; +}; +extern int check[sizeof(struct s4) == 4 ? 1 : -1]; +extern int check[offsetof(struct s4, f3) == 2 ? 1 : -1]; diff --git a/clang/test/Sema/pragma-pack-and-options-align.c b/clang/test/Sema/pragma-pack-and-options-align.c new file mode 100644 index 0000000..ebf1ade --- /dev/null +++ b/clang/test/Sema/pragma-pack-and-options-align.c @@ -0,0 +1,42 @@ +// RUN: %clang_cc1 -triple i686-apple-darwin9 %s -fsyntax-only -verify + +// Check that #pragma pack and #pragma options share the same stack. + +#pragma pack(push, 1) +struct s0 { + char c; + int x; +}; +extern int a[sizeof(struct s0) == 5 ? 1 : -1]; + +#pragma options align=natural +struct s1 { + char c; + int x; +}; +extern int a[sizeof(struct s1) == 8 ? 1 : -1]; + +#pragma options align=reset +#pragma options align=native +struct s1_1 { + char c; + int x; +}; +extern int a[sizeof(struct s1_1) == 8 ? 1 : -1]; + +#pragma pack(pop) +struct s2 { + char c; + int x; +}; +extern int a[sizeof(struct s2) == 5 ? 1 : -1]; +#pragma pack(pop) + +struct s3 { + char c; + int x; +}; +extern int a[sizeof(struct s3) == 8 ? 1 : -1]; + +/* expected-warning {{#pragma options align=reset failed: stack empty}} */ #pragma options align=reset +/* expected-warning {{#pragma pack(pop, ...) failed: stack empty}} */ #pragma pack(pop) diff --git a/clang/test/Sema/pragma-pack-apple.c b/clang/test/Sema/pragma-pack-apple.c new file mode 100644 index 0000000..5b33c03 --- /dev/null +++ b/clang/test/Sema/pragma-pack-apple.c @@ -0,0 +1,10 @@ +// RUN: %clang -fsyntax-only %s 2>&1 | FileCheck %s +// RUN: %clang -fsyntax-only -fapple-pragma-pack %s 2>&1 | FileCheck -check-prefix=CHECK-APPLE %s + +#pragma pack(push,1) +#pragma pack(2) +#pragma pack() +#pragma pack(show) + +// CHECK: pack(show) == 8 +// CHECK-APPLE: pack(show) == 1 diff --git a/clang/test/Sema/pragma-pack.c b/clang/test/Sema/pragma-pack.c new file mode 100644 index 0000000..e93ce42 --- /dev/null +++ b/clang/test/Sema/pragma-pack.c @@ -0,0 +1,27 @@ +// RUN: %clang_cc1 -triple i686-apple-darwin9 -fsyntax-only -verify %s + +/* expected-warning {{value of #pragma pack(show) == 8}} */ #pragma pack(show) +/* expected-warning {{expected #pragma pack parameter to be}} */ #pragma pack(3) +/* expected-warning {{value of #pragma pack(show) == 8}} */ #pragma pack(show) +#pragma pack(4) +/* expected-warning {{value of #pragma pack(show) == 4}} */ #pragma pack(show) +#pragma pack() // resets to default +/* expected-warning {{value of #pragma pack(show) == 8}} */ #pragma pack(show) +#pragma pack(2) +#pragma pack(push, eek, 16) // -> (eek, 2), 16 +/* expected-warning {{value of #pragma pack(show) == 16}} */ #pragma pack(show) +#pragma pack(push) // -> (eek, 2), (, 2), 16 +/* expected-warning {{value of #pragma pack(show) == 16}} */ #pragma pack(show) +#pragma pack(1) +#pragma pack(push, 8) // -> (eek, 2), (, 2), (, 1), 8 +/* expected-warning {{value of #pragma pack(show) == 8}} */ #pragma pack(show) +#pragma pack(pop) // -> (eek, 2), (,2), 1 +/* expected-warning {{value of #pragma pack(show) == 1}} */ #pragma pack(show) +#pragma pack(pop, eek) +/* expected-warning {{value of #pragma pack(show) == 2}} */ #pragma pack(show) +/* expected-warning {{pack(pop, ...) failed: stack empty}} */ #pragma pack(pop) + +#pragma pack(push) +#pragma pack(pop, 16) +/* expected-warning {{value of #pragma pack(show) == 16}} */ #pragma pack(show) + diff --git a/clang/test/Sema/pragma-unused.c b/clang/test/Sema/pragma-unused.c new file mode 100644 index 0000000..aafac0d --- /dev/null +++ b/clang/test/Sema/pragma-unused.c @@ -0,0 +1,65 @@ +// RUN: %clang_cc1 -fsyntax-only -Wunused-parameter -Wused-but-marked-unused -Wunused -verify %s + +void f1(void) { + int x, y, z; + #pragma unused(x) + #pragma unused(y, z) + + int w; // expected-warning {{unused}} + #pragma unused w // expected-warning{{missing '(' after '#pragma unused' - ignoring}} +} + +void f2(void) { + int x, y; // expected-warning {{unused}} expected-warning {{unused}} + #pragma unused(x,) // expected-warning{{expected '#pragma unused' argument to be a variable name}} + #pragma unused() // expected-warning{{expected '#pragma unused' argument to be a variable name}} +} + +void f3(void) { + #pragma unused(x) // expected-warning{{undeclared variable 'x' used as an argument for '#pragma unused'}} +} + +void f4(void) { + int w; // expected-warning {{unused}} + #pragma unused((w)) // expected-warning{{expected '#pragma unused' argument to be a variable name}} +} + +void f6(void) { + int z; // no-warning + { + #pragma unused(z) // no-warning + } +} + +void f7() { + int y; + #pragma unused(undeclared, undefined, y) // expected-warning{{undeclared variable 'undeclared' used as an argument for '#pragma unused'}} expected-warning{{undeclared variable 'undefined' used as an argument for '#pragma unused'}} +} + +int f8(int x) { // expected-warning{{unused parameter 'x'}} + return 0; +} + +int f9(int x) { + return x; +} + +int f10(int x) { + #pragma unused(x) + return 0; +} + +int f11(int x) { + #pragma unused(x) + return x; // expected-warning{{'x' was marked unused but was used}} +} + +int f12(int x) { + int y = x; + #pragma unused(x) // expected-warning{{'x' was marked unused but was used}} + return y; +} + +// rdar://8793832 +static int glob_var = 0; +#pragma unused(glob_var) diff --git a/clang/test/Sema/predef.c b/clang/test/Sema/predef.c new file mode 100644 index 0000000..95bcfb9 --- /dev/null +++ b/clang/test/Sema/predef.c @@ -0,0 +1,19 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +void abcdefghi12(void) { + const char (*ss)[12] = &__func__; + static int arr[sizeof(__func__)==12 ? 1 : -1]; +} + +char *X = __func__; // expected-warning {{predefined identifier is only valid}} \ + expected-warning {{initializing 'char *' with an expression of type 'const char [1]' discards qualifiers}} + +void a() { + __func__[0] = 'a'; // expected-error {{variable is not assignable}} +} + +// rdar://6097892 - GCC permits this insanity. +const char *b = __func__; // expected-warning {{predefined identifier is only valid}} +const char *c = __FUNCTION__; // expected-warning {{predefined identifier is only valid}} +const char *d = __PRETTY_FUNCTION__; // expected-warning {{predefined identifier is only valid}} + diff --git a/clang/test/Sema/predefined-function.c b/clang/test/Sema/predefined-function.c new file mode 100644 index 0000000..1c40b6e --- /dev/null +++ b/clang/test/Sema/predefined-function.c @@ -0,0 +1,38 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -pedantic %s + +char *funk(int format); +enum Test {A=-1}; +char *funk(enum Test x); + +int eli(float b); // expected-note {{previous declaration is here}} \ +// expected-note{{passing argument to parameter 'b' here}} +int b(int c) {return 1;} + +int foo(); +int foo() { + int eli(int (int)); // expected-error {{conflicting types for 'eli'}} + eli(b); // expected-error{{passing 'int (int)' to parameter of incompatible type 'float'}} + return 0; +} + +int bar(); +int bar(int i) // expected-note {{previous definition is here}} +{ + return 0; +} +int bar() // expected-error {{redefinition of 'bar'}} +{ + return 0; +} + +int foobar(int); // note {{previous declaration is here}} +int foobar() // error {{conflicting types for 'foobar'}} +{ + return 0; +} + +int wibble(); // expected-note {{previous declaration is here}} +float wibble() // expected-error {{conflicting types for 'wibble'}} +{ + return 0.0f; +} diff --git a/clang/test/Sema/private-extern.c b/clang/test/Sema/private-extern.c new file mode 100644 index 0000000..25591dc --- /dev/null +++ b/clang/test/Sema/private-extern.c @@ -0,0 +1,84 @@ +// RUN: %clang_cc1 -verify -fsyntax-only %s + +static int g0; // expected-note{{previous definition}} +int g0; // expected-error{{non-static declaration of 'g0' follows static declaration}} + +static int g1; +extern int g1; + +static int g2; +__private_extern__ int g2; + +int g3; // expected-note{{previous definition}} +static int g3; // expected-error{{static declaration of 'g3' follows non-static declaration}} + +extern int g4; // expected-note{{previous definition}} +static int g4; // expected-error{{static declaration of 'g4' follows non-static declaration}} + +__private_extern__ int g5; // expected-note{{previous definition}} +static int g5; // expected-error{{static declaration of 'g5' follows non-static declaration}} + +void f0() { + int g6; // expected-note {{previous}} + extern int g6; // expected-error {{extern declaration of 'g6' follows non-extern declaration}} +} + +void f1() { + int g7; // expected-note {{previous}} + __private_extern__ int g7; // expected-error {{extern declaration of 'g7' follows non-extern declaration}} +} + +void f2() { + extern int g8; // expected-note{{previous definition}} + int g8; // expected-error {{non-extern declaration of 'g8' follows extern declaration}} +} + +void f3() { + __private_extern__ int g9; // expected-note{{previous definition}} + int g9; // expected-error {{non-extern declaration of 'g9' follows extern declaration}} +} + +void f4() { + extern int g10; + extern int g10; +} + +void f5() { + __private_extern__ int g11; + __private_extern__ int g11; +} + +void f6() { + // FIXME: Diagnose + extern int g12; + __private_extern__ int g12; +} + +void f7() { + // FIXME: Diagnose + __private_extern__ int g13; + extern int g13; +} + +struct s0; +void f8() { + extern struct s0 g14; + __private_extern__ struct s0 g14; +} +struct s0 { int x; }; + +void f9() { + extern int g15 = 0; // expected-error{{'extern' variable cannot have an initializer}} + // FIXME: linkage specifier in warning. + __private_extern__ int g16 = 0; // expected-error{{'extern' variable cannot have an initializer}} +} + +extern int g17; +int g17 = 0; + +extern int g18 = 0; // expected-warning{{'extern' variable has an initializer}} + +__private_extern__ int g19; +int g19 = 0; + +__private_extern__ int g20 = 0; diff --git a/clang/test/Sema/rdr6094103-unordered-compare-promote.c b/clang/test/Sema/rdr6094103-unordered-compare-promote.c new file mode 100644 index 0000000..7bb363e --- /dev/null +++ b/clang/test/Sema/rdr6094103-unordered-compare-promote.c @@ -0,0 +1,6 @@ +// RUN: %clang_cc1 -ast-dump %s 2>&1 | grep ImplicitCastExpr | count 4 + +int foo (double x, long double y) { + // There needs to be an implicit cast on x here. + return __builtin_isgreater(x, y); +} diff --git a/clang/test/Sema/recover-goto.c b/clang/test/Sema/recover-goto.c new file mode 100644 index 0000000..0e8f6d3 --- /dev/null +++ b/clang/test/Sema/recover-goto.c @@ -0,0 +1,5 @@ +// RUN: %clang_cc1 -fsyntax-only %s -verify + +void a() { // expected-note {{to match this '{'}} + goto A; // expected-error {{use of undeclared label}} +// expected-error {{expected '}'}} diff --git a/clang/test/Sema/redefinition.c b/clang/test/Sema/redefinition.c new file mode 100644 index 0000000..1ee35f7 --- /dev/null +++ b/clang/test/Sema/redefinition.c @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify +int f(int a) { return 0; } // expected-note {{previous definition is here}} +int f(int); +int f(int a) { return 0; } // expected-error {{redefinition of 'f'}} + +// <rdar://problem/6097326> +int foo(x) { + return 0; +} +int x = 1; + +// <rdar://problem/6880464> +extern inline int g(void) { return 0; } // expected-note{{previous definition}} +int g(void) { return 0; } // expected-error{{redefinition of a 'extern inline' function 'g' is not supported in C99 mode}} diff --git a/clang/test/Sema/return-noreturn.c b/clang/test/Sema/return-noreturn.c new file mode 100644 index 0000000..448fce7 --- /dev/null +++ b/clang/test/Sema/return-noreturn.c @@ -0,0 +1,37 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify -fblocks -Wmissing-noreturn -Wno-unreachable-code + +int j; +void test1() { // expected-warning {{function 'test1' could be declared with attribute 'noreturn'}} + ^ (void) { while (1) { } }(); // expected-warning {{block could be declared with attribute 'noreturn'}} + ^ (void) { if (j) while (1) { } }(); + while (1) { } +} + +void test2() { + if (j) while (1) { } +} + +__attribute__((__noreturn__)) +void test2_positive() { + if (j) while (1) { } +} // expected-warning{{function declared 'noreturn' should not return}} + + +// This test case illustrates that we don't warn about the missing return +// because the function is marked noreturn and there is an infinite loop. +extern int foo_test_3(); +__attribute__((__noreturn__)) void* test3(int arg) { + while (1) foo_test_3(); +} + +__attribute__((__noreturn__)) void* test3_positive(int arg) { + while (0) foo_test_3(); +} // expected-warning{{function declared 'noreturn' should not return}} + + +// PR5298 - -Wmissing-noreturn shouldn't warn if the function is already +// declared noreturn. +void __attribute__((noreturn)) +test4() { + test2_positive(); +} diff --git a/clang/test/Sema/return-silent.c b/clang/test/Sema/return-silent.c new file mode 100644 index 0000000..eb9641b --- /dev/null +++ b/clang/test/Sema/return-silent.c @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 %s -Wno-return-type -fsyntax-only -verify + +int t14() { + return; +} + +void t15() { + return 1; +} diff --git a/clang/test/Sema/return.c b/clang/test/Sema/return.c new file mode 100644 index 0000000..77bd3f6 --- /dev/null +++ b/clang/test/Sema/return.c @@ -0,0 +1,266 @@ +// RUN: %clang %s -fsyntax-only -Wignored-qualifiers -Wno-error=return-type -Xclang -verify -fblocks -Wno-unreachable-code -Wno-unused-value + +// clang emits the following warning by default. +// With GCC, -pedantic, -Wreturn-type or -Wall are required to produce the +// following warning. +int t14() { + return; // expected-warning {{non-void function 't14' should return a value}} +} + +void t15() { + return 1; // expected-warning {{void function 't15' should not return a value}} +} + +int unknown(); + +void test0() { +} + +int test1() { +} // expected-warning {{control reaches end of non-void function}} + +int test2() { + a: goto a; +} + +int test3() { + goto a; + a: ; +} // expected-warning {{control reaches end of non-void function}} + + +void halt() { + a: goto a; +} + +void halt2() __attribute__((noreturn)); + +int test4() { + halt2(); +} + +int test5() { + halt2(), (void)1; +} + +int test6() { + 1, halt2(); +} + +int j; +int unknown_nohalt() { + return j; +} + +int test7() { + unknown(); +} // expected-warning {{control reaches end of non-void function}} + +int test8() { + (void)(1 + unknown()); +} // expected-warning {{control reaches end of non-void function}} + +int halt3() __attribute__((noreturn)); + +int test9() { + (void)(halt3() + unknown()); +} + +int test10() { + (void)(unknown() || halt3()); +} // expected-warning {{control may reach end of non-void function}} + +int test11() { + (void)(unknown() && halt3()); +} // expected-warning {{control may reach end of non-void function}} + +int test12() { + (void)(halt3() || unknown()); +} + +int test13() { + (void)(halt3() && unknown()); +} + +int test14() { + (void)(1 || unknown()); +} // expected-warning {{control reaches end of non-void function}} + +int test15() { + (void)(0 || unknown()); +} // expected-warning {{control reaches end of non-void function}} + +int test16() { + (void)(0 && unknown()); +} // expected-warning {{control reaches end of non-void function}} + +int test17() { + (void)(1 && unknown()); +} // expected-warning {{control reaches end of non-void function}} + +int test18() { + (void)(unknown_nohalt() && halt3()); +} // expected-warning {{control may reach end of non-void function}} + +int test19() { + (void)(unknown_nohalt() && unknown()); +} // expected-warning {{control reaches end of non-void function}} + +int test20() { + int i; + if (i) + return 0; + else if (0) + return 2; +} // expected-warning {{control may reach end of non-void function}} + +int test21() { + int i; + if (i) + return 0; + else if (1) + return 2; +} + +int test22() { + int i; + switch (i) default: ; +} // expected-warning {{control reaches end of non-void function}} + +int test23() { + int i; + switch (i) { + case 0: + return 0; + case 2: + return 2; + } +} // expected-warning {{control may reach end of non-void function}} + +int test24() { + int i; + switch (i) { + case 0: + return 0; + case 2: + return 2; + default: + return -1; + } +} + +int test25() { + 1 ? halt3() : unknown(); +} + +int test26() { + 0 ? halt3() : unknown(); +} // expected-warning {{control reaches end of non-void function}} + +int j; +void (*fptr)() __attribute__((noreturn)); +int test27() { + switch (j) { + case 1: + do { } while (1); + break; + case 2: + for (;;) ; + break; + case 3: + for (;1;) ; + for (;0;) { + goto done; + } + return 1; + case 4: + while (0) { goto done; } + return 1; + case 5: + while (1) { return 1; } + break; + case 6: + fptr(); + break; + default: + return 1; + } + done: ; +} + +// PR4624 +void test28() __attribute__((noreturn)); +void test28(x) { while (1) { } } + +void exit(int); +int test29() { + exit(1); +} + +#include <setjmp.h> +jmp_buf test30_j; +int test30() { + if (j) + longjmp(test30_j, 1); + else +#if defined(_WIN32) || defined(_WIN64) || defined(__CYGWIN__) + longjmp(test30_j, 2); +#else + _longjmp(test30_j, 1); +#endif +} + +typedef void test31_t(int status); +void test31(test31_t *callback __attribute__((noreturn))); + +void test32() { + ^ (void) { while (1) { } }(); + ^ (void) { if (j) while (1) { } }(); + while (1) { } +} + +void test33() { + if (j) while (1) { } +} + +// Test that 'static inline' functions are only analyzed for CFG-based warnings +// when they are used. +static inline int si_has_missing_return() {} // expected-warning{{control reaches end of non-void function}} +static inline int si_has_missing_return_2() {}; // expected-warning{{control reaches end of non-void function}} +static inline int si_forward(); +static inline int si_has_missing_return_3(int x) { + if (x) + return si_has_missing_return_3(x+1); +} // expected-warning{{control may reach end of non-void function}} + +int test_static_inline(int x) { + si_forward(); + return x ? si_has_missing_return_2() : si_has_missing_return_3(x); +} +static inline int si_forward() {} // expected-warning{{control reaches end of non-void function}} + +// Test warnings on ignored qualifiers on return types. +const int ignored_c_quals(); // expected-warning{{'const' type qualifier on return type has no effect}} +const volatile int ignored_cv_quals(); // expected-warning{{'const volatile' type qualifiers on return type have no effect}} +char* const volatile restrict ignored_cvr_quals(); // expected-warning{{'const volatile restrict' type qualifiers on return type have no effect}} + +// Test that for switch(enum) that if the switch statement covers all the cases +// that we don't consider that for -Wreturn-type. +enum Cases { C1, C2, C3, C4 }; +int test_enum_cases(enum Cases C) { + switch (C) { + case C1: return 1; + case C2: return 2; + case C4: return 3; + case C3: return 4; + } +} // no-warning + +// PR12318 - Don't give a may reach end of non-void function warning. +int test34(int x) { + if (x == 1) { + return 3; + } else if ( x == 2 || 1) { + return 5; + } +} diff --git a/clang/test/Sema/scope-check.c b/clang/test/Sema/scope-check.c new file mode 100644 index 0000000..a9494d3 --- /dev/null +++ b/clang/test/Sema/scope-check.c @@ -0,0 +1,234 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -fblocks -std=gnu99 %s -Wno-unreachable-code + +int test1(int x) { + goto L; // expected-error{{goto into protected scope}} + int a[x]; // expected-note {{jump bypasses initialization of variable length array}} + int b[x]; // expected-note {{jump bypasses initialization of variable length array}} + L: + return sizeof a; +} + +int test2(int x) { + goto L; // expected-error{{goto into protected scope}} + typedef int a[x]; // expected-note {{jump bypasses initialization of VLA typedef}} + L: + return sizeof(a); +} + +void test3clean(int*); + +int test3() { + goto L; // expected-error{{goto into protected scope}} +int a __attribute((cleanup(test3clean))); // expected-note {{jump bypasses initialization of variable with __attribute__((cleanup))}} +L: + return a; +} + +int test4(int x) { + goto L; // expected-error{{goto into protected scope}} +int a[x]; // expected-note {{jump bypasses initialization of variable length array}} + test4(x); +L: + return sizeof a; +} + +int test5(int x) { + int a[x]; + test5(x); + goto L; // Ok. +L: + goto L; // Ok. + return sizeof a; +} + +int test6() { + // just plain invalid. + goto x; // expected-error {{use of undeclared label 'x'}} +} + +void test7(int x) { + switch (x) { + case 1: ; + int a[x]; // expected-note {{jump bypasses initialization of variable length array}} + case 2: // expected-error {{switch case is in protected scope}} + a[1] = 2; + break; + } +} + +int test8(int x) { + // For statement. + goto L2; // expected-error {{goto into protected scope}} + for (int arr[x]; // expected-note {{jump bypasses initialization of variable length array}} + ; ++x) + L2:; + + // Statement expressions. + goto L3; // expected-error {{goto into protected scope}} + int Y = ({ int a[x]; // expected-note {{jump bypasses initialization of variable length array}} + L3: 4; }); + + goto L4; // expected-error {{goto into protected scope}} + { + int A[x], // expected-note {{jump bypasses initialization of variable length array}} + B[x]; // expected-note {{jump bypasses initialization of variable length array}} + L4: ; + } + + { + L5: ;// ok + int A[x], B = ({ if (x) + goto L5; + else + goto L6; + 4; }); + L6:; // ok. + if (x) goto L6; // ok + } + + { + L7: ;// ok + int A[x], B = ({ if (x) + goto L7; + else + goto L8; // expected-error {{goto into protected scope}} + 4; }), + C[x]; // expected-note {{jump bypasses initialization of variable length array}} + L8:; // bad + } + + { + L9: ;// ok + int A[({ if (x) + goto L9; + else + // FIXME: + goto L10; // fixme-error {{goto into protected scope}} + 4; })]; + L10:; // bad + } + + { + // FIXME: Crashes goto checker. + //goto L11;// ok + //int A[({ L11: 4; })]; + } + + { + goto L12; + + int y = 4; // fixme-warn: skips initializer. + L12: + ; + } + + // Statement expressions 2. + goto L1; // expected-error {{goto into protected scope}} + return x == ({ + int a[x]; // expected-note {{jump bypasses initialization of variable length array}} + L1: + 42; }); +} + +void test9(int n, void *P) { + int Y; + int Z = 4; + goto *P; // expected-error {{indirect goto might cross protected scopes}} + +L2: ; + int a[n]; // expected-note {{jump bypasses initialization of variable length array}} + +L3: // expected-note {{possible target of indirect goto}} +L4: + goto *P; + goto L3; // ok + goto L4; // ok + + void *Ptrs[] = { + &&L2, + &&L3 + }; +} + +void test10(int n, void *P) { + goto L0; // expected-error {{goto into protected scope}} + typedef int A[n]; // expected-note {{jump bypasses initialization of VLA typedef}} +L0: + + goto L1; // expected-error {{goto into protected scope}} + A b, c[10]; // expected-note 2 {{jump bypasses initialization of variable length array}} +L1: + goto L2; // expected-error {{goto into protected scope}} + A d[n]; // expected-note {{jump bypasses initialization of variable length array}} +L2: + return; +} + +void test11(int n) { + void *P = ^{ + switch (n) { + case 1:; + case 2: + case 3:; + int Arr[n]; // expected-note {{jump bypasses initialization of variable length array}} + case 4: // expected-error {{switch case is in protected scope}} + return; + } + }; +} + + +// TODO: When and if gotos are allowed in blocks, this should work. +void test12(int n) { + void *P = ^{ + goto L1; + L1: + goto L2; + L2: + goto L3; // expected-error {{goto into protected scope}} + int Arr[n]; // expected-note {{jump bypasses initialization of variable length array}} + L3: + goto L4; + L4: return; + }; +} + +void test13(int n, void *p) { + int vla[n]; + goto *p; + a0: ; + static void *ps[] = { &&a0 }; +} + +int test14(int n) { + static void *ps[] = { &&a0, &&a1 }; + if (n < 0) + goto *&&a0; + + if (n > 0) { + int vla[n]; + a1: + vla[n-1] = 0; + } + a0: + return 0; +} + + +// PR8473: IR gen can't deal with indirect gotos past VLA +// initialization, so that really needs to be a hard error. +void test15(int n, void *pc) { + static const void *addrs[] = { &&L1, &&L2 }; + + goto *pc; // expected-error {{indirect goto might cross protected scope}} + + L1: + { + char vla[n]; // expected-note {{jump bypasses initialization}} + L2: // expected-note {{possible target}} + vla[0] = 'a'; + } +} + +// rdar://9024687 +int test16(int [sizeof &&z]); // expected-error {{use of address-of-label extension outside of a function body}} diff --git a/clang/test/Sema/self-comparison.c b/clang/test/Sema/self-comparison.c new file mode 100644 index 0000000..edb3a6a --- /dev/null +++ b/clang/test/Sema/self-comparison.c @@ -0,0 +1,88 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +int foo(int x) { + return x == x; // expected-warning {{self-comparison always evaluates to true}} +} + +int foo2(int x) { + return (x) != (((x))); // expected-warning {{self-comparison always evaluates to false}} +} + +void foo3(short s, short t) { + if (s == s) {} // expected-warning {{self-comparison always evaluates to true}} + if (s == t) {} // no-warning +} + +void foo4(void* v, void* w) { + if (v == v) {} // expected-warning {{self-comparison always evaluates to true}} + if (v == w) {} // no-warning +} + +int qux(int x) { + return x < x; // expected-warning {{self-comparison}} +} + +int qux2(int x) { + return x > x; // expected-warning {{self-comparison}} +} + +int bar(float x) { + return x == x; // no-warning +} + +int bar2(float x) { + return x != x; // no-warning +} + +#define IS_THE_ANSWER(x) (x == 42) + +int macro_comparison() { + return IS_THE_ANSWER(42); +} + +// Don't complain in unevaluated contexts. +int compare_sizeof(int x) { + return sizeof(x == x); // no-warning +} + +int array_comparisons() { + int array1[2]; + int array2[2]; + + // + // compare same array + // + return array1 == array1; // expected-warning{{self-comparison always evaluates to true}} + return array1 != array1; // expected-warning{{self-comparison always evaluates to false}} + return array1 < array1; // expected-warning{{self-comparison always evaluates to false}} + return array1 <= array1; // expected-warning{{self-comparison always evaluates to true}} + return array1 > array1; // expected-warning{{self-comparison always evaluates to false}} + return array1 >= array1; // expected-warning{{self-comparison always evaluates to true}} + + // + // compare differrent arrays + // + return array1 == array2; // expected-warning{{array comparison always evaluates to false}} + return array1 != array2; // expected-warning{{array comparison always evaluates to true}} + + // + // we don't know what these are going to be + // + return array1 < array2; // expected-warning{{array comparison always evaluates to a constant}} + return array1 <= array2; // expected-warning{{array comparison always evaluates to a constant}} + return array1 > array2; // expected-warning{{array comparison always evaluates to a constant}} + return array1 >= array2; // expected-warning{{array comparison always evaluates to a constant}} + +} + +// Don't issue a warning when either the left or right side of the comparison +// results from a macro expansion. <rdar://problem/8435950> +#define R8435950_A i +#define R8435950_B i + +int R8435950(int i) { + if (R8435950_A == R8435950_B) // no-warning + return 0; + return 1; +} + diff --git a/clang/test/Sema/sentinel-attribute.c b/clang/test/Sema/sentinel-attribute.c new file mode 100644 index 0000000..e5cbf6e --- /dev/null +++ b/clang/test/Sema/sentinel-attribute.c @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +int x __attribute__((sentinel)); //expected-warning{{'sentinel' attribute only applies to functions, methods and blocks}} + +void f1(int a, ...) __attribute__ ((sentinel)); +void f2(int a, ...) __attribute__ ((sentinel(1))); + +void f3(int a, ...) __attribute__ ((sentinel("hello"))); //expected-error{{'sentinel' attribute requires parameter 1 to be an integer constant}} +void f4(int a, ...) __attribute__ ((sentinel(1, 2, 3))); //expected-error{{attribute takes no more than 2 arguments}} +void f4(int a, ...) __attribute__ ((sentinel(-1))); //expected-error{{parameter 1 less than zero}} +void f4(int a, ...) __attribute__ ((sentinel(0, 2))); // expected-error{{parameter 2 not 0 or 1}} + +void f5(int a) __attribute__ ((sentinel)); //expected-warning{{'sentinel' attribute only supported for variadic functions}} + + +void f6() __attribute__((__sentinel__)); // expected-warning {{'sentinel' attribute requires named arguments}} diff --git a/clang/test/Sema/shift.c b/clang/test/Sema/shift.c new file mode 100644 index 0000000..142d83c --- /dev/null +++ b/clang/test/Sema/shift.c @@ -0,0 +1,68 @@ +// RUN: %clang -Wall -Wshift-sign-overflow -ffreestanding -fsyntax-only -Xclang -verify %s + +#include <limits.h> + +#define WORD_BIT (sizeof(int) * CHAR_BIT) + +enum { + X = 1 << 0, + Y = 1 << 1, + Z = 1 << 2 +}; + +void test() { + char c; + + c = 0 << 0; + c = 0 << 1; + c = 1 << 0; + c = 1 << -0; + c = 1 >> -0; + c = 1 << -1; // expected-warning {{shift count is negative}} + c = 1 >> -1; // expected-warning {{shift count is negative}} + c = 1 << c; + c <<= 0; + c >>= 0; + c <<= 1; + c >>= 1; + c <<= -1; // expected-warning {{shift count is negative}} + c >>= -1; // expected-warning {{shift count is negative}} + c <<= 999999; // expected-warning {{shift count >= width of type}} + c >>= 999999; // expected-warning {{shift count >= width of type}} + c <<= CHAR_BIT; // expected-warning {{shift count >= width of type}} + c >>= CHAR_BIT; // expected-warning {{shift count >= width of type}} + c <<= CHAR_BIT+1; // expected-warning {{shift count >= width of type}} + c >>= CHAR_BIT+1; // expected-warning {{shift count >= width of type}} + (void)((long)c << CHAR_BIT); + + int i; + i = 1 << (WORD_BIT - 2); + i = 2 << (WORD_BIT - 1); // expected-warning {{bits to represent, but 'int' only has}} + i = 1 << (WORD_BIT - 1); // expected-warning {{sets the sign bit of the shift expression}} + i = -1 << (WORD_BIT - 1); + i = 0 << (WORD_BIT - 1); + i = (char)1 << (WORD_BIT - 2); + + unsigned u; + u = 1U << (WORD_BIT - 1); + u = 5U << (WORD_BIT - 1); + + long long int lli; + lli = INT_MIN << 2; // expected-warning {{bits to represent, but 'int' only has}} + lli = 1LL << (sizeof(long long) * CHAR_BIT - 2); +} + +#define a 0 +#define ashift 8 +enum { b = (a << ashift) }; + +// Don't warn for negative shifts in code that is unreachable. +void test_pr5544() { + (void) (((1) > 63 && (1) < 128 ? (((unsigned long long) 1)<<((1)-64)) : (unsigned long long) 0)); // no-warning +} + +void test_shift_too_much(char x) { + if (0) + (void) (x >> 80); // no-warning + (void) (x >> 80); // expected-warning {{shift count >= width of type}} +} diff --git a/clang/test/Sema/short-enums.c b/clang/test/Sema/short-enums.c new file mode 100644 index 0000000..6605c4e --- /dev/null +++ b/clang/test/Sema/short-enums.c @@ -0,0 +1,5 @@ +// RUN: not %clang_cc1 -fsyntax-only %s -verify +// RUN: %clang_cc1 -fshort-enums -fsyntax-only %s -verify + +enum x { A }; +int t0[sizeof(enum x) == 1 ? 1 : -1]; diff --git a/clang/test/Sema/sign-conversion.c b/clang/test/Sema/sign-conversion.c new file mode 100644 index 0000000..4b1ee75 --- /dev/null +++ b/clang/test/Sema/sign-conversion.c @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wsign-conversion %s + +// PR9345: make a subgroup of -Wconversion for signedness changes + +void test(int x) { + unsigned t0 = x; // expected-warning {{implicit conversion changes signedness}} + unsigned t1 = (t0 == 5 ? x : 0); // expected-warning {{operand of ? changes signedness}} +} diff --git a/clang/test/Sema/statements.c b/clang/test/Sema/statements.c new file mode 100644 index 0000000..f01ee40 --- /dev/null +++ b/clang/test/Sema/statements.c @@ -0,0 +1,102 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify + +typedef unsigned __uint32_t; + +#define __byte_swap_int_var(x) \ +__extension__ ({ register __uint32_t __X = (x); \ + __asm ("bswap %0" : "+r" (__X)); \ + __X; }) + +int test(int _x) { + return (__byte_swap_int_var(_x)); +} + +// PR2374 +int test2() { return ({L:5;}); } +int test3() { return ({ {5;} }); } // expected-error {{returning 'void' from a function with incompatible result type 'int'}}\ + // expected-warning {{expression result unused}} +int test4() { return ({ ({5;}); }); } +int test5() { return ({L1: L2: L3: 5;}); } +int test6() { return ({5;}); } +void test7() { ({5;}); } // expected-warning {{expression result unused}} + +// PR3062 +int test8[({10;})]; // expected-error {{statement expression not allowed at file scope}} + +// PR3912 +void test9(const void *P) { + __builtin_prefetch(P); +} + + +void *test10() { +bar: + return &&bar; // expected-warning {{returning address of label, which is local}} +} + +// PR6034 +void test11(int bit) { + switch (bit) // expected-warning {{switch statement has empty body}} expected-note {{put the semicolon on a separate line to silence this warning}} + switch (env->fpscr) // expected-error {{use of undeclared identifier 'env'}} + { + } +} + +// rdar://3271964 +enum Numbers { kOne, kTwo, kThree, kFour}; +int test12(enum Numbers num) { + switch (num == kOne) {// expected-warning {{switch condition has boolean value}} + default: + case kThree: + break; + } +} + + +enum x { a, b, c, d, e, f, g }; + +void foo(enum x X) { + switch (X) { // expected-warning {{enumeration value 'g' not handled in switch}} + case a: + case b: + case c: + case d: + case e: + case f: + break; + } + + switch (X) { // expected-warning {{enumeration values 'f' and 'g' not handled in switch}} + case a: + case b: + case c: + case d: + case e: + break; + } + + switch (X) { // expected-warning {{enumeration values 'e', 'f', and 'g' not handled in switch}} + case a: + case b: + case c: + case d: + break; + } + + switch (X) { // expected-warning {{5 enumeration values not handled in switch: 'c', 'd', 'e'...}} + case a: + case b: + break; + } +} + +// PR 8880 +// FIXME: Clang should reject this, since GCC does. Previously this +// was causing a crash in the CFG builder. +int test_pr8880() { + int first = 1; + for ( ; ({ if (first) { first = 0; continue; } 0; }); ) + return 0; + return 1; +} + diff --git a/clang/test/Sema/static-array.c b/clang/test/Sema/static-array.c new file mode 100644 index 0000000..2d4b968 --- /dev/null +++ b/clang/test/Sema/static-array.c @@ -0,0 +1,31 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +void cat0(int a[static 0]) {} // expected-warning {{'static' has no effect on zero-length arrays}} + +void cat(int a[static 3]) {} // expected-note 2 {{callee declares array parameter as static here}} + +typedef int i3[static 3]; +void tcat(i3 a) {} + +void vat(int i, int a[static i]) {} // expected-note {{callee declares array parameter as static here}} + +void f(int *p) { + int a[2], b[3], c[4]; + + cat0(0); + + cat(0); // expected-warning {{null passed to a callee which requires a non-null argument}} + cat(a); // expected-warning {{array argument is too small; contains 2 elements, callee requires at least 3}} + cat(b); + cat(c); + cat(p); + + tcat(0); // expected-warning {{null passed to a callee which requires a non-null argument}} + tcat(a); // expected-warning {{array argument is too small; contains 2 elements, callee requires at least 3}} + tcat(b); + tcat(c); + tcat(p); + + vat(1, 0); // expected-warning {{null passed to a callee which requires a non-null argument}} + vat(3, b); +} diff --git a/clang/test/Sema/static-assert.c b/clang/test/Sema/static-assert.c new file mode 100644 index 0000000..13d7070 --- /dev/null +++ b/clang/test/Sema/static-assert.c @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -std=c1x -fsyntax-only -verify %s + +_Static_assert("foo", "string is nonzero"); // expected-error {{static_assert expression is not an integral constant expression}} + +_Static_assert(1, "1 is nonzero"); +_Static_assert(0, "0 is nonzero"); // expected-error {{static_assert failed "0 is nonzero"}} + +void foo(void) { + _Static_assert(1, "1 is nonzero"); + _Static_assert(0, "0 is nonzero"); // expected-error {{static_assert failed "0 is nonzero"}} +} diff --git a/clang/test/Sema/static-init.c b/clang/test/Sema/static-init.c new file mode 100644 index 0000000..bbf9038 --- /dev/null +++ b/clang/test/Sema/static-init.c @@ -0,0 +1,24 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +typedef __typeof((int*) 0 - (int*) 0) intptr_t; + +static int f = 10; +static int b = f; // expected-error {{initializer element is not a compile-time constant}} + +float r = (float) (intptr_t) &r; // expected-error {{initializer element is not a compile-time constant}} +intptr_t s = (intptr_t) &s; +_Bool t = &t; + + +union bar { + int i; +}; + +struct foo { + short ptr; +}; + +union bar u[1]; +struct foo x = {(intptr_t) u}; // expected-error {{initializer element is not a compile-time constant}} +struct foo y = {(char) u}; // expected-error {{initializer element is not a compile-time constant}} +intptr_t z = (intptr_t) u; // no-error diff --git a/clang/test/Sema/stdcall-fastcall.c b/clang/test/Sema/stdcall-fastcall.c new file mode 100644 index 0000000..eeacf94 --- /dev/null +++ b/clang/test/Sema/stdcall-fastcall.c @@ -0,0 +1,21 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-pc-linux-gnu %s +// RUN: %clang_cc1 -fsyntax-only -verify -triple i686-apple-darwin10 %s + +// CC qualifier can be applied only to functions +int __attribute__((stdcall)) var1; // expected-warning{{'stdcall' only applies to function types; type here is 'int'}} +int __attribute__((fastcall)) var2; // expected-warning{{'fastcall' only applies to function types; type here is 'int'}} + +// Different CC qualifiers are not compatible +void __attribute__((stdcall, fastcall)) foo3(void); // expected-error{{fastcall and stdcall attributes are not compatible}} +void __attribute__((stdcall)) foo4(); // expected-note{{previous declaration is here}} +void __attribute__((fastcall)) foo4(void); // expected-error{{function declared 'fastcall' here was previously declared 'stdcall'}} + +// rdar://8876096 +void rdar8876096foo1(int i, int j) __attribute__((fastcall, cdecl)); // expected-error {{not compatible}} +void rdar8876096foo2(int i, int j) __attribute__((fastcall, stdcall)); // expected-error {{not compatible}} +void rdar8876096foo3(int i, int j) __attribute__((fastcall, regparm(2))); // expected-error {{not compatible}} +void rdar8876096foo4(int i, int j) __attribute__((stdcall, cdecl)); // expected-error {{not compatible}} +void rdar8876096foo5(int i, int j) __attribute__((stdcall, fastcall)); // expected-error {{not compatible}} +void rdar8876096foo6(int i, int j) __attribute__((cdecl, fastcall)); // expected-error {{not compatible}} +void rdar8876096foo7(int i, int j) __attribute__((cdecl, stdcall)); // expected-error {{not compatible}} +void rdar8876096foo8(int i, int j) __attribute__((regparm(2), fastcall)); // expected-error {{not compatible}} diff --git a/clang/test/Sema/struct-cast.c b/clang/test/Sema/struct-cast.c new file mode 100644 index 0000000..30ef892 --- /dev/null +++ b/clang/test/Sema/struct-cast.c @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -fsyntax-only %s -verify + +struct S { + int one; + int two; +}; + +struct S const foo(void); + + +struct S tmp; + +void priv_sock_init() { + tmp = (struct S)foo(); +} diff --git a/clang/test/Sema/struct-compat.c b/clang/test/Sema/struct-compat.c new file mode 100644 index 0000000..65bef9f --- /dev/null +++ b/clang/test/Sema/struct-compat.c @@ -0,0 +1,17 @@ +/* RUN: %clang_cc1 %s -fsyntax-only -pedantic -verify + */ + +extern struct {int a;} x; // expected-note {{previous definition is here}} +extern struct {int a;} x; // expected-error {{redefinition of 'x'}} + +struct x; +int a(struct x* b) { +// Per C99 6.7.2.3, since the outer and inner "struct x"es have different +// scopes, they don't refer to the same type, and are therefore incompatible +struct x {int a;} *c = b; // expected-warning {{incompatible pointer types}} +} + +struct x {int a;} r; +int b() { +struct x {char x;} s = r; // expected-error {{initializing 'struct x' with an expression of incompatible type 'struct x'}} +} diff --git a/clang/test/Sema/struct-decl.c b/clang/test/Sema/struct-decl.c new file mode 100644 index 0000000..6070e87 --- /dev/null +++ b/clang/test/Sema/struct-decl.c @@ -0,0 +1,59 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +// PR3459 +struct bar { + char n[1]; +}; + +struct foo { + char name[(int)&((struct bar *)0)->n]; + char name2[(int)&((struct bar *)0)->n - 1]; //expected-error{{'name2' declared as an array with a negative size}} +}; + +// PR3430 +struct s { + struct st { + int v; + } *ts; +}; + +struct st; + +int foo() { + struct st *f; + return f->v + f[0].v; +} + +// PR3642, PR3671 +struct pppoe_tag { + short tag_type; + char tag_data[]; +}; +struct datatag { + struct pppoe_tag hdr; //expected-warning{{field 'hdr' with variable sized type 'struct pppoe_tag' not at the end of a struct or class is a GNU extension}} + char data; +}; + + +// PR4092 +struct s0 { + char a; // expected-note {{previous declaration is here}} + char a; // expected-error {{duplicate member 'a'}} +}; + +struct s0 f0(void) {} + +// <rdar://problem/8177927> - This previously triggered an assertion failure. +struct x0 { + unsigned int x1; +}; + +// rdar://problem/9150338 +static struct test1 { // expected-warning {{'static' ignored on this declaration}} + int x; +}; +const struct test2 { // expected-warning {{'const' ignored on this declaration}} + int x; +}; +inline struct test3 { // expected-warning {{'inline' ignored on this declaration}} + int x; +}; diff --git a/clang/test/Sema/struct-packed-align.c b/clang/test/Sema/struct-packed-align.c new file mode 100644 index 0000000..6ca6a60 --- /dev/null +++ b/clang/test/Sema/struct-packed-align.c @@ -0,0 +1,134 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify + +// Packed structs. +struct s { + char a; + int b __attribute__((packed)); + char c; + int d; +}; + +extern int a1[sizeof(struct s) == 12 ? 1 : -1]; +extern int a2[__alignof(struct s) == 4 ? 1 : -1]; + +struct __attribute__((packed)) packed_s { + char a; + int b __attribute__((packed)); + char c; + int d; +}; + +extern int b1[sizeof(struct packed_s) == 10 ? 1 : -1]; +extern int b2[__alignof(struct packed_s) == 1 ? 1 : -1]; + +struct fas { + char a; + int b[]; +}; + +extern int c1[sizeof(struct fas) == 4 ? 1 : -1]; +extern int c2[__alignof(struct fas) == 4 ? 1 : -1]; + +struct __attribute__((packed)) packed_fas { + char a; + int b[]; +}; + +extern int d1[sizeof(struct packed_fas) == 1 ? 1 : -1]; +extern int d2[__alignof(struct packed_fas) == 1 ? 1 : -1]; + +struct packed_after_fas { + char a; + int b[]; +} __attribute__((packed)); + +extern int d1_2[sizeof(struct packed_after_fas) == 1 ? 1 : -1]; +extern int d2_2[__alignof(struct packed_after_fas) == 1 ? 1 : -1]; + +// Alignment + +struct __attribute__((aligned(8))) as1 { + char c; +}; + +extern int e1[sizeof(struct as1) == 8 ? 1 : -1]; +extern int e2[__alignof(struct as1) == 8 ? 1 : -1]; + +// FIXME: Will need to force arch once max usable alignment isn't hard +// coded. +struct __attribute__((aligned)) as1_2 { + char c; +}; +extern int e1_2[sizeof(struct as1_2) == 16 ? 1 : -1]; +extern int e2_2[__alignof(struct as1_2) == 16 ? 1 : -1]; + +struct as2 { + char c; + int __attribute__((aligned(8))) a; +}; + +extern int f1[sizeof(struct as2) == 16 ? 1 : -1]; +extern int f2[__alignof(struct as2) == 8 ? 1 : -1]; + +struct __attribute__((packed)) as3 { + char c; + int a; + int __attribute__((aligned(8))) b; +}; + +extern int g1[sizeof(struct as3) == 16 ? 1 : -1]; +extern int g2[__alignof(struct as3) == 8 ? 1 : -1]; + + +// rdar://5921025 +struct packedtest { + int ted_likes_cheese; + void *args[] __attribute__((packed)); +}; + +// Packed union +union __attribute__((packed)) au4 {char c; int x;}; +extern int h1[sizeof(union au4) == 4 ? 1 : -1]; +extern int h2[__alignof(union au4) == 1 ? 1 : -1]; + +// Aligned union +union au5 {__attribute__((aligned(4))) char c;}; +extern int h1[sizeof(union au5) == 4 ? 1 : -1]; +extern int h2[__alignof(union au5) == 4 ? 1 : -1]; + +// Alignment+packed +struct as6 {char c; __attribute__((packed, aligned(2))) int x;}; +extern int i1[sizeof(struct as6) == 6 ? 1 : -1]; +extern int i2[__alignof(struct as6) == 2 ? 1 : -1]; + +union au6 {char c; __attribute__((packed, aligned(2))) int x;}; +extern int k1[sizeof(union au6) == 4 ? 1 : -1]; +extern int k2[__alignof(union au6) == 2 ? 1 : -1]; + +// Check postfix attributes +union au7 {char c; int x;} __attribute__((packed)); +extern int l1[sizeof(union au7) == 4 ? 1 : -1]; +extern int l2[__alignof(union au7) == 1 ? 1 : -1]; + +struct packed_fas2 { + char a; + int b[]; +} __attribute__((packed)); + +extern int m1[sizeof(struct packed_fas2) == 1 ? 1 : -1]; +extern int m2[__alignof(struct packed_fas2) == 1 ? 1 : -1]; + +// Attribute aligned can round down typedefs. PR9253 +typedef long long __attribute__((aligned(1))) nt; + +struct nS { + char buf_nr; + nt start_lba; +}; + +extern int n1[sizeof(struct nS) == 9 ? 1 : -1]; +extern int n2[__alignof(struct nS) == 1 ? 1 : -1]; + + + + diff --git a/clang/test/Sema/surpress-deprecated.c b/clang/test/Sema/surpress-deprecated.c new file mode 100644 index 0000000..dd673b9 --- /dev/null +++ b/clang/test/Sema/surpress-deprecated.c @@ -0,0 +1,7 @@ +// RUN: %clang_cc1 -fsyntax-only -Wno-deprecated-declarations -verify %s +extern void OldFunction() __attribute__((deprecated)); + +int main (int argc, const char * argv[]) { + OldFunction(); +} + diff --git a/clang/test/Sema/switch.c b/clang/test/Sema/switch.c new file mode 100644 index 0000000..a7a7f60 --- /dev/null +++ b/clang/test/Sema/switch.c @@ -0,0 +1,322 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wswitch-enum -Wcovered-switch-default %s +void f (int z) { + while (z) { + default: z--; // expected-error {{statement not in switch}} + } +} + +void foo(int X) { + switch (X) { + case 42: ; // expected-note {{previous case}} + case 5000000000LL: // expected-warning {{overflow}} + case 42: // expected-error {{duplicate case value}} + ; + + case 100 ... 99: ; // expected-warning {{empty case range}} + + case 43: ; // expected-note {{previous case}} + case 43 ... 45: ; // expected-error {{duplicate case value}} + + case 100 ... 20000:; // expected-note {{previous case}} + case 15000 ... 40000000:; // expected-error {{duplicate case value}} + } +} + +void test3(void) { + // empty switch; + switch (0); // expected-warning {{no case matching constant switch condition '0'}} \ + // expected-warning {{switch statement has empty body}} \ + // expected-note{{put the semicolon on a separate line to silence this warning}} +} + +extern int g(); + +void test4() +{ + int cond; + switch (cond) { + case 0 && g(): + case 1 || g(): + break; + } + + switch(cond) { + case g(): // expected-error {{expression is not an integer constant expression}} + case 0 ... g(): // expected-error {{expression is not an integer constant expression}} + break; + } + + switch (cond) { + case 0 && g() ... 1 || g(): + break; + } + + switch (cond) { + case g() // expected-error {{expression is not an integer constant expression}} + && 0: + break; + } + + switch (cond) { + case 0 ... + g() // expected-error {{expression is not an integer constant expression}} + || 1: + break; + } +} + +void test5(int z) { + switch(z) { + default: // expected-note {{previous case defined here}} + default: // expected-error {{multiple default labels in one switch}} + break; + } +} + +void test6() { + char ch = 'a'; + switch(ch) { + case 1234: // expected-warning {{overflow converting case value}} + break; + } +} + +// PR5606 +int f0(int var) { + switch (va) { // expected-error{{use of undeclared identifier 'va'}} + case 1: + break; + case 2: + return 1; + } + return 2; +} + +void test7() { + enum { + A = 1, + B + } a; + switch(a) { //expected-warning{{enumeration value 'B' not handled in switch}} + case A: + break; + } + switch(a) { + case B: + case A: + break; + } + switch(a) { + case A: + case B: + case 3: // expected-warning{{case value not in enumerated type 'enum <anonymous enum}} + break; + } + switch(a) { + case A: + case B: + case 3 ... //expected-warning{{case value not in enumerated type 'enum <anonymous enum}} + 4: //expected-warning{{case value not in enumerated type 'enum <anonymous enum}} + break; + } + switch(a) { + case 1 ... 2: + break; + } + switch(a) { + case 0 ... 2: //expected-warning{{case value not in enumerated type 'enum <anonymous enum}} + break; + } + switch(a) { + case 1 ... 3: //expected-warning{{case value not in enumerated type 'enum <anonymous enum}} + break; + } + switch(a) { + case 0 ... //expected-warning{{case value not in enumerated type 'enum <anonymous enum}} + 3: //expected-warning{{case value not in enumerated type 'enum <anonymous enum}} + break; + } + +} + +void test8() { + enum { + A, + B, + C = 1 + } a; + switch(a) { + case A: + case B: + break; + } + switch(a) { + case A: + case C: + break; + } + switch(a) { //expected-warning{{enumeration value 'B' not handled in switch}} + case A: + break; + } +} + +void test9() { + enum { + A = 3, + C = 1 + } a; + switch(a) { + case 0: //expected-warning{{case value not in enumerated type 'enum <anonymous enum}} + case 1: + case 2: //expected-warning{{case value not in enumerated type 'enum <anonymous enum}} + case 3: + case 4: //expected-warning{{case value not in enumerated type 'enum <anonymous enum}} + break; + } +} + +void test10() { + enum { + A = 10, + C = 2, + B = 4, + D = 12 + } a; + switch(a) { + case 0 ... //expected-warning{{case value not in enumerated type 'enum <anonymous enum}} + 1: //expected-warning{{case value not in enumerated type 'enum <anonymous enum}} + case 2 ... 4: + case 5 ... //expected-warning{{case value not in enumerated type 'enum <anonymous enum}} + 9: //expected-warning{{case value not in enumerated type 'enum <anonymous enum}} + case 10 ... 12: + case 13 ... //expected-warning{{case value not in enumerated type 'enum <anonymous enum}} + 16: //expected-warning{{case value not in enumerated type 'enum <anonymous enum}} + break; + } +} + +void test11() { + enum { + A = -1, + B, + C + } a; + switch(a) { //expected-warning{{enumeration value 'A' not handled in switch}} + case B: + case C: + break; + } + + switch(a) { //expected-warning{{enumeration value 'A' not explicitly handled in switch}} + case B: + case C: + break; + + default: + break; + } +} + +void test12() { + enum { + A = -1, + B = 4294967286 + } a; + switch(a) { + case A: + case B: + break; + } +} + +// <rdar://problem/7643909> +typedef enum { + val1, + val2, + val3 +} my_type_t; + +int test13(my_type_t t) { + switch(t) { // expected-warning{{enumeration value 'val3' not handled in switch}} + case val1: + return 1; + case val2: + return 2; + } + return -1; +} + +// <rdar://problem/7658121> +enum { + EC0 = 0xFFFF0000, + EC1 = 0xFFFF0001, +}; + +int test14(int a) { + switch(a) { + case EC0: return 0; + case EC1: return 1; + } + return 0; +} + +void f1(unsigned x) { + switch (x) { + case -1: break; + default: break; + } +} + +void test15() { + int i = 0; + switch (1) { // expected-warning {{no case matching constant switch condition '1'}} + case 0: i = 0; break; + case 2: i++; break; + } +} + +void test16() { + const char c = '5'; + switch (c) { // expected-warning {{no case matching constant switch condition '53'}} + case '6': return; + } +} + +// PR7359 +void test17(int x) { + switch (x >= 17) { // expected-warning {{switch condition has boolean value}} + case 0: return; + } + + switch ((int) (x <= 17)) { + case 0: return; + } +} + +int test18() { + enum { A, B } a; + switch (a) { + case A: return 0; + case B: return 1; + case 7: return 1; // expected-warning {{case value not in enumerated type}} + default: return 2; // expected-warning {{default label in switch which covers all enumeration values}} + } +} + +// rdar://110822110 +typedef enum { + kOne = 1, +} Ints; + +void rdar110822110(Ints i) +{ + switch (i) { + case kOne: + break; + case 2: // expected-warning {{case value not in enumerated type 'Ints'}} + break; + default: // expected-warning {{default label in switch which covers all enumeration values}} + break; + } +} diff --git a/clang/test/Sema/tentative-decls.c b/clang/test/Sema/tentative-decls.c new file mode 100644 index 0000000..b15537b --- /dev/null +++ b/clang/test/Sema/tentative-decls.c @@ -0,0 +1,65 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify + +// PR3310 +struct a x1; // expected-note 2{{forward declaration of 'struct a'}} +static struct a x2; // expected-warning{{tentative definition of variable with internal linkage has incomplete non-array type 'struct a'}} +struct a x3[10]; // expected-error{{array has incomplete element type 'struct a'}} +struct a {int x;}; +static struct a x2_okay; +struct a x3_okay[10]; +struct b x4; // expected-error{{tentative definition has type 'struct b' that is never completed}} \ + // expected-note{{forward declaration of 'struct b'}} + +const int a [1] = {1}; +extern const int a[]; + +extern const int b[]; +const int b [1] = {1}; + +extern const int c[] = {1}; // expected-warning{{'extern' variable has an initializer}} +const int c[]; + +int i1 = 1; // expected-note {{previous definition is here}} +int i1 = 2; // expected-error {{redefinition of 'i1'}} +int i1; +int i1; +extern int i5; // expected-note {{previous definition is here}} +static int i5; // expected-error{{static declaration of 'i5' follows non-static declaration}} + +static int i2 = 5; // expected-note 1 {{previous definition is here}} +int i2 = 3; // expected-error{{non-static declaration of 'i2' follows static declaration}} + +static int i3 = 5; +extern int i3; + +__private_extern__ int pExtern; +int pExtern = 0; + +int i4; +int i4; +extern int i4; + +int (*pToArray)[]; +int (*pToArray)[8]; + +int redef[10]; +int redef[]; // expected-note {{previous definition is here}} +int redef[11]; // expected-error{{redefinition of 'redef'}} + +void func() { + extern int i6; // expected-note {{previous definition is here}} + static int i6; // expected-error{{static declaration of 'i6' follows non-static declaration}} +} + +void func2(void) +{ + extern double *p; + extern double *p; +} + +// <rdar://problem/6808352> +static int a0[]; +static int b0; + +static int a0[] = { 4 }; +static int b0 = 5; diff --git a/clang/test/Sema/text-diag.c b/clang/test/Sema/text-diag.c new file mode 100644 index 0000000..6dcaaa8 --- /dev/null +++ b/clang/test/Sema/text-diag.c @@ -0,0 +1,4 @@ +// RUN: %clang_cc1 -fsyntax-only %s +unsigned char *foo = "texto\ +que continua\ +e continua"; diff --git a/clang/test/Sema/thread-specifier.c b/clang/test/Sema/thread-specifier.c new file mode 100644 index 0000000..9ec88c5 --- /dev/null +++ b/clang/test/Sema/thread-specifier.c @@ -0,0 +1,21 @@ +// RUN: %clang_cc1 -triple i686-pc-linux-gnu -fsyntax-only -verify %s + +__thread int t1; +__thread extern int t2; +__thread static int t3; +__thread __private_extern__ int t4; +struct t5 { __thread int x; }; // expected-error {{type name does not allow storage class to be specified}} +__thread int t6(); // expected-error {{'__thread' is only allowed on variable declarations}} +int f(__thread int t7) { // expected-error {{'__thread' is only allowed on variable declarations}} + __thread int t8; // expected-error {{'__thread' variables must have global storage}} + __thread extern int t9; + __thread static int t10; + __thread __private_extern__ int t11; + __thread auto int t12; // expected-error {{'__thread' variables must have global storage}} + __thread register int t13; // expected-error {{'__thread' variables must have global storage}} +} +__thread typedef int t14; // expected-error {{'__thread' is only allowed on variable declarations}} +__thread int t15; // expected-note {{previous definition is here}} +int t15; // expected-error {{non-thread-local declaration of 't15' follows thread-local declaration}} +int t16; // expected-note {{previous definition is here}} +__thread int t16; // expected-error {{thread-local declaration of 't16' follows non-thread-local declaration}} diff --git a/clang/test/Sema/transparent-union-pointer.c b/clang/test/Sema/transparent-union-pointer.c new file mode 100644 index 0000000..31c9391 --- /dev/null +++ b/clang/test/Sema/transparent-union-pointer.c @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify + +typedef union { + union wait *__uptr; + int *__iptr; +} __WAIT_STATUS __attribute__ ((__transparent_union__)); + +extern int wait (__WAIT_STATUS __stat_loc); + +void fastcgi_cleanup() { + int status = 0; + wait(&status); +} + diff --git a/clang/test/Sema/transparent-union.c b/clang/test/Sema/transparent-union.c new file mode 100644 index 0000000..ab1ba18 --- /dev/null +++ b/clang/test/Sema/transparent-union.c @@ -0,0 +1,73 @@ +// RUN: %clang -fsyntax-only -Xclang -verify %s +typedef union { + int *ip; + float *fp; + long *__restrict rlp; + void *vpa[1]; +} TU __attribute__((transparent_union)); + +void f(TU); // expected-note{{passing argument to parameter here}} + +void g(int *ip, float *fp, char *cp) { + f(ip); + f(fp); + f(cp); // expected-error{{incompatible type}} + f(0); + + TU tu_ip = ip; // expected-error{{incompatible type}} + TU tu; + tu.ip = ip; +} + +/* Test ability to redeclare a function taking a transparent_union arg + with various compatible and incompatible argument types. */ + +void fip(TU); +void fip(int *i) {} + +void ffp(TU); +void ffp(float *f) {} + +void flp(TU); +void flp(long *l) {} + +void fvp(TU); // expected-note{{previous declaration is here}} +void fvp(void *p) {} // expected-error{{conflicting types}} + +void fsp(TU); // expected-note{{previous declaration is here}} +void fsp(short *s) {} // expected-error{{conflicting types}} + +void fi(TU); // expected-note{{previous declaration is here}} +void fi(int i) {} // expected-error{{conflicting types}} + +void fvpp(TU); // expected-note{{previous declaration is here}} +void fvpp(void **v) {} // expected-error{{conflicting types}} + +/* FIXME: we'd like to just use an "int" here and align it differently + from the normal "int", but if we do so we lose the alignment + information from the typedef within the compiler. */ +typedef struct { int x, y; } __attribute__((aligned(8))) aligned_struct8; + +typedef struct { int x, y; } __attribute__((aligned(4))) aligned_struct4; +typedef union { + aligned_struct4 s4; // expected-note{{alignment of first field}} + aligned_struct8 s8; // expected-warning{{alignment of field}} +} TU1 __attribute__((transparent_union)); + +typedef union { + char c; // expected-note{{size of first field is 8 bits}} + int i; // expected-warning{{size of field}} +} TU2 __attribute__((transparent_union)); + +typedef union { + float f; // expected-warning{{floating}} +} TU3 __attribute__((transparent_union)); + +typedef union { } TU4 __attribute__((transparent_union)); // expected-warning{{field}} + +typedef int int4 __attribute__((ext_vector_type(4))); +typedef union { + int4 vec; // expected-warning{{first field of a transparent union cannot have vector type 'int4'; transparent_union attribute ignored}} +} TU5 __attribute__((transparent_union)); + + diff --git a/clang/test/Sema/type-spec-struct-union.c b/clang/test/Sema/type-spec-struct-union.c new file mode 100644 index 0000000..ce65095 --- /dev/null +++ b/clang/test/Sema/type-spec-struct-union.c @@ -0,0 +1,65 @@ +// RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s + +/* This test checks the introduction of struct and union types based + on a type specifier of the form "struct-or-union identifier" when they + type has not yet been declared. See C99 6.7.2.3p8. */ + +typedef struct S1 { + union { + struct S2 *x; + struct S3 *y; + } u1; +} S1; + +int test_struct_scope(S1 *s1, struct S2 *s2, struct S3 *s3) { + if (s1->u1.x == s2) return 1; + if (s1->u1.y == s3) return 1; + return 0; +} + +int test_struct_scope_2(S1 *s1) { + struct S2 { int x; } *s2 = 0; + if (s1->u1.x == s2) return 1; /* expected-warning {{comparison of distinct pointer types ('struct S2 *' and 'struct S2 *')}} */ + return 0; +} + +// FIXME: We do not properly implement C99 6.2.1p4, which says that +// the type "struct S4" declared in the function parameter list has +// block scope within the function definition. The problem, in this +// case, is that the code is ill-formed but we warn about the two S4's +// being incompatible (we think they are two different types). +int test_struct_scope_3(struct S4 * s4) { // expected-warning{{declaration of 'struct S4' will not be visible outside of this function}} + struct S4 { int y; } *s4_2 = 0; + /* if (s4 == s4_2) return 1; */ + return 0; +} + +void f(struct S5 { int y; } s5); // expected-warning{{declaration of 'struct S5' will not be visible outside of this function}} + +// PR clang/3312 +struct S6 { + enum { BAR } e; +}; + +void test_S6() { + struct S6 a; + a.e = BAR; +} + +// <rdar://problem/6487669> +typedef struct z_foo_s { + struct bar_baz *baz; +} z_foo; +typedef z_foo *z_foop; +struct bar_baz { + enum { + SQUAT, FLAG, DICT4, DICT3, DICT2, DICT1, DICT0, HOP, CHECK4, CHECK3, CHECK2, CHECK1, DONE, BAD + } mode; + int nowrap; +}; +void +wizbiz_quxPoof(z) + z_foop z; +{ + z->baz->mode = z->baz->nowrap ? HOP : SQUAT; +} diff --git a/clang/test/Sema/typecheck-binop.c b/clang/test/Sema/typecheck-binop.c new file mode 100644 index 0000000..be52d0b --- /dev/null +++ b/clang/test/Sema/typecheck-binop.c @@ -0,0 +1,27 @@ +/* RUN: %clang_cc1 %s -fsyntax-only -pedantic -verify + */ +struct incomplete; // expected-note{{forward declaration of 'struct incomplete'}} + +int sub1(int *a, double *b) { + return a - b; /* expected-error{{not pointers to compatible types}} */ +} + +void *sub2(struct incomplete *P) { + return P-4; /* expected-error{{arithmetic on a pointer to an incomplete type 'struct incomplete'}} */ +} + +void *sub3(void *P) { + return P-4; /* expected-warning{{arithmetic on a pointer to void is a GNU extension}} */ +} + +int sub4(void *P, void *Q) { + return P-Q; /* expected-warning{{arithmetic on pointers to void is a GNU extension}} */ +} + +int sub5(void *P, int *Q) { + return P-Q; /* expected-error{{not pointers to compatible types}} */ +} + +int logicaland1(int a) { + return a && (void)a; /* expected-error{{invalid operands}} */ +} diff --git a/clang/test/Sema/typedef-prototype.c b/clang/test/Sema/typedef-prototype.c new file mode 100644 index 0000000..8372154 --- /dev/null +++ b/clang/test/Sema/typedef-prototype.c @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +typedef int unary_int_func(int arg); +unary_int_func add_one; + +int add_one(int arg) { + return arg + 1; +} diff --git a/clang/test/Sema/typedef-redef.c b/clang/test/Sema/typedef-redef.c new file mode 100644 index 0000000..025f65c --- /dev/null +++ b/clang/test/Sema/typedef-redef.c @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +typedef const int x; // expected-note {{previous definition is here}} +extern x a; +typedef int x; // expected-error {{typedef redefinition with different types}} +extern x a; + +// <rdar://problem/6097585> +int y; // expected-note 2 {{previous definition is here}} +float y; // expected-error{{redefinition of 'y' with a different type}} +double y; // expected-error{{redefinition of 'y' with a different type}} diff --git a/clang/test/Sema/typedef-retain.c b/clang/test/Sema/typedef-retain.c new file mode 100644 index 0000000..a7173b7 --- /dev/null +++ b/clang/test/Sema/typedef-retain.c @@ -0,0 +1,26 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -fno-lax-vector-conversions + +typedef float float4 __attribute__((vector_size(16))); +typedef int int4 __attribute__((vector_size(16))); +typedef int4* int4p; + +void test1(float4 a, int4 *result, int i) { + result[i] = a; // expected-error {{assigning to 'int4' from incompatible type 'float4'}} +} + +void test2(float4 a, int4p result, int i) { + result[i] = a; // expected-error {{assigning to 'int4' from incompatible type 'float4'}} +} + +// PR2039 +typedef int a[5]; +void test3() { + typedef const a b; + b r; + r[0]=10; // expected-error {{read-only variable is not assignable}} +} + +int test4(const a y) { + y[0] = 10; // expected-error {{read-only variable is not assignable}} +} + diff --git a/clang/test/Sema/typedef-variable-type.c b/clang/test/Sema/typedef-variable-type.c new file mode 100644 index 0000000..8a7ee8b --- /dev/null +++ b/clang/test/Sema/typedef-variable-type.c @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only -pedantic -Wno-typedef-redefinition -std=c99 + +// Make sure we accept a single typedef +typedef int (*a)[!.0]; // expected-warning{{size of static array must be an integer constant expression}} + +// And make sure we accept identical redefinitions in system headers +// (The test uses -Wno-typedef-redefinition to simulate this.) +typedef int (*a)[!.0]; // expected-warning{{size of static array must be an integer constant expression}} diff --git a/clang/test/Sema/typeof-use-deprecated.c b/clang/test/Sema/typeof-use-deprecated.c new file mode 100644 index 0000000..238e501 --- /dev/null +++ b/clang/test/Sema/typeof-use-deprecated.c @@ -0,0 +1,26 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only + +struct s { int a; } __attribute__((deprecated)) x; // expected-warning {{'s' is deprecated}} + +typeof(x) y; // expected-warning {{'s' is deprecated}} + +union un{ int a; } __attribute__((deprecated)) u; // expected-warning {{'un' is deprecated}} + +typeof( u) z; // expected-warning {{'un' is deprecated}} + +enum E{ one} __attribute__((deprecated)) e; // expected-warning {{'E' is deprecated}} + +typeof( e) w; // expected-warning {{'E' is deprecated}} + +struct foo { int x; } __attribute__((deprecated)); +typedef struct foo bar __attribute__((deprecated)); +bar x1; // expected-warning {{'bar' is deprecated}} + +int main() { typeof(x1) y; } // expected-warning {{'foo' is deprecated}} + +struct gorf { int x; }; +typedef struct gorf T __attribute__((deprecated)); +T t; // expected-warning {{'T' is deprecated}} +void wee() { typeof(t) y; } + + diff --git a/clang/test/Sema/types.c b/clang/test/Sema/types.c new file mode 100644 index 0000000..3bec83e --- /dev/null +++ b/clang/test/Sema/types.c @@ -0,0 +1,66 @@ +// RUN: %clang_cc1 %s -pedantic -verify -triple=x86_64-apple-darwin9 + +// rdar://6097662 +typedef int (*T)[2]; +restrict T x; + +typedef int *S[2]; +restrict S y; // expected-error {{restrict requires a pointer or reference ('S' (aka 'int *[2]') is invalid)}} + + + +// int128_t is available. +int a() { + __int128_t s; + __uint128_t t; +} +// but not a keyword +int b() { + int __int128_t; + int __uint128_t; +} +// __int128 is a keyword +int c() { + __int128 i; + unsigned __int128 j; + long unsigned __int128 k; // expected-error {{'long __int128' is invalid}} + int __int128; // expected-error {{cannot combine with previous}} expected-warning {{does not declare anything}} +} +// __int128_t is __int128; __uint128_t is unsigned __int128. +typedef __int128 check_int_128; // expected-note {{here}} +typedef __int128_t check_int_128; // expected-note {{here}} expected-warning {{redefinition}} +typedef int check_int_128; // expected-error {{different types ('int' vs '__int128_t' (aka '__int128'))}} + +typedef unsigned __int128 check_uint_128; // expected-note {{here}} +typedef __uint128_t check_uint_128; // expected-note {{here}} expected-warning {{redefinition}} +typedef int check_uint_128; // expected-error {{different types ('int' vs '__uint128_t' (aka 'unsigned __int128'))}} + +// Array type merging should convert array size to whatever matches the target +// pointer size. +// rdar://6880874 +extern int i[1LL]; +int i[(short)1]; + +enum e { e_1 }; +extern int j[sizeof(enum e)]; // expected-note {{previous definition}} +int j[42]; // expected-error {{redefinition of 'j' with a different type}} + +// rdar://6880104 +_Decimal32 x; // expected-error {{GNU decimal type extension not supported}} + + +// rdar://6880951 +int __attribute__ ((vector_size (8), vector_size (8))) v; // expected-error {{invalid vector element type}} + +void test(int i) { + char c = (char __attribute__((align(8)))) i; // expected-error {{'align' attribute ignored when parsing type}} +} + +// http://llvm.org/PR11082 +// +// FIXME: This may or may not be the correct approach (no warning or error), +// but large amounts of Linux and FreeBSD code need this attribute to not be +// a hard error in order to work correctly. +void test2(int i) { + char c = (char __attribute__((may_alias))) i; +} diff --git a/clang/test/Sema/ucn-cstring.c b/clang/test/Sema/ucn-cstring.c new file mode 100644 index 0000000..5d3e85d --- /dev/null +++ b/clang/test/Sema/ucn-cstring.c @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only -pedantic + +int printf(const char *, ...); + +int main(void) { + int a[sizeof("hello \u2192 \u2603 \u2190 world") == 24 ? 1 : -1]; + + printf("%s (%zd)\n", "hello \u2192 \u2603 \u2190 world", sizeof("hello \u2192 \u2603 \u2190 world")); + printf("%s (%zd)\n", "\U00010400\U0001D12B", sizeof("\U00010400\U0001D12B")); + // Some error conditions... + printf("%s\n", "\U"); // expected-error{{\u used with no following hex digits}} + printf("%s\n", "\U00"); // expected-error{{incomplete universal character name}} + printf("%s\n", "\U0001"); // expected-error{{incomplete universal character name}} + printf("%s\n", "\u0001"); // expected-error{{universal character name refers to a control character}} + return 0; +} diff --git a/clang/test/Sema/uninit-variables-vectors.c b/clang/test/Sema/uninit-variables-vectors.c new file mode 100644 index 0000000..10a8ecc --- /dev/null +++ b/clang/test/Sema/uninit-variables-vectors.c @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin10.0.0 -fsyntax-only -Wuninitialized -fsyntax-only %s -verify + +typedef int __v4si __attribute__((__vector_size__(16))); +typedef float __m128 __attribute__((__vector_size__(16))); +__m128 _mm_xor_ps(__m128 a, __m128 b); +__m128 _mm_loadu_ps(const float *p); + +void test1(float *input) { + __m128 x, y, z, w, X; // expected-note {{variable 'x' is declared here}} expected-note {{variable 'y' is declared here}} expected-note {{variable 'w' is declared here}} expected-note {{variable 'z' is declared here}} + x = _mm_xor_ps(x,x); // expected-warning {{variable 'x' is uninitialized when used here}} + y = _mm_xor_ps(y,y); // expected-warning {{variable 'y' is uninitialized when used here}} + z = _mm_xor_ps(z,z); // expected-warning {{variable 'z' is uninitialized when used here}} + w = _mm_xor_ps(w,w); // expected-warning {{variable 'w' is uninitialized when used here}} + X = _mm_loadu_ps(&input[0]); + X = _mm_xor_ps(X,X); // no-warning +} + diff --git a/clang/test/Sema/uninit-variables.c b/clang/test/Sema/uninit-variables.c new file mode 100644 index 0000000..d62186d --- /dev/null +++ b/clang/test/Sema/uninit-variables.c @@ -0,0 +1,426 @@ +// RUN: %clang_cc1 -fsyntax-only -Wuninitialized -Wconditional-uninitialized -fsyntax-only -fblocks %s -verify + +typedef __typeof(sizeof(int)) size_t; +void *malloc(size_t); + +int test1() { + int x; // expected-note{{initialize the variable 'x' to silence this warning}} + return x; // expected-warning{{variable 'x' is uninitialized when used here}} +} + +int test2() { + int x = 0; + return x; // no-warning +} + +int test3() { + int x; + x = 0; + return x; // no-warning +} + +int test4() { + int x; // expected-note{{initialize the variable 'x' to silence this warning}} + ++x; // expected-warning{{variable 'x' is uninitialized when used here}} + return x; +} + +int test5() { + int x, y; // expected-note{{initialize the variable 'y' to silence this warning}} + x = y; // expected-warning{{variable 'y' is uninitialized when used here}} + return x; +} + +int test6() { + int x; // expected-note{{initialize the variable 'x' to silence this warning}} + x += 2; // expected-warning{{variable 'x' is uninitialized when used here}} + return x; +} + +int test7(int y) { + int x; // expected-note{{initialize the variable 'x' to silence this warning}} + if (y) + x = 1; + return x; // expected-warning{{variable 'x' may be uninitialized when used here}} +} + +int test7b(int y) { + int x = x; // expected-note{{variable 'x' is declared here}} + if (y) + x = 1; + // Warn with "may be uninitialized" here (not "is uninitialized"), since the + // self-initialization is intended to suppress a -Wuninitialized warning. + return x; // expected-warning{{variable 'x' may be uninitialized when used here}} +} + +int test8(int y) { + int x; + if (y) + x = 1; + else + x = 0; + return x; +} + +int test9(int n) { + int x; // expected-note{{initialize the variable 'x' to silence this warning}} + for (unsigned i = 0 ; i < n; ++i) { + if (i == n - 1) + break; + x = 1; + } + return x; // expected-warning{{variable 'x' may be uninitialized when used here}} +} + +int test10(unsigned n) { + int x; // expected-note{{initialize the variable 'x' to silence this warning}} + for (unsigned i = 0 ; i < n; ++i) { + x = 1; + } + return x; // expected-warning{{variable 'x' may be uninitialized when used here}} +} + +int test11(unsigned n) { + int x; // expected-note{{initialize the variable 'x' to silence this warning}} + for (unsigned i = 0 ; i <= n; ++i) { + x = 1; + } + return x; // expected-warning{{variable 'x' may be uninitialized when used here}} +} + +void test12(unsigned n) { + for (unsigned i ; n ; ++i) ; // expected-warning{{variable 'i' is uninitialized when used here}} expected-note{{initialize the variable 'i' to silence this warning}} +} + +int test13() { + static int i; + return i; // no-warning +} + +// Simply don't crash on this test case. +void test14() { + const char *p = 0; + for (;;) {} +} + +void test15() { + int x = x; // no-warning: signals intended lack of initialization. +} + +int test15b() { + // Warn here with the self-init, since it does result in a use of + // an unintialized variable and this is the root cause. + int x = x; // expected-warning {{variable 'x' is uninitialized when used within its own initialization}} + return x; +} + +// Don't warn in the following example; shows dataflow confluence. +char *test16_aux(); +void test16() { + char *p = test16_aux(); + for (unsigned i = 0 ; i < 100 ; i++) + p[i] = 'a'; // no-warning +} + +void test17() { + // Don't warn multiple times about the same uninitialized variable + // along the same path. + int *x; // expected-note{{initialize the variable 'x' to silence this warning}} + *x = 1; // expected-warning{{variable 'x' is uninitialized when used here}} + *x = 1; // no-warning +} + +int test18(int x, int y) { + int z; + if (x && y && (z = 1)) { + return z; // no-warning + } + return 0; +} + +int test19_aux1(); +int test19_aux2(); +int test19_aux3(int *x); +int test19() { + int z; + if (test19_aux1() + test19_aux2() && test19_aux1() && test19_aux3(&z)) + return z; // no-warning + return 0; +} + +int test20() { + int z; // expected-note{{initialize the variable 'z' to silence this warning}} + if ((test19_aux1() + test19_aux2() && test19_aux1()) || test19_aux3(&z)) + return z; // expected-warning{{variable 'z' may be uninitialized when used here}} + return 0; +} + +int test21(int x, int y) { + int z; // expected-note{{initialize the variable 'z' to silence this warning}} + if ((x && y) || test19_aux3(&z) || test19_aux2()) + return z; // expected-warning{{variable 'z' may be uninitialized when used here}} + return 0; +} + +int test22() { + int z; + while (test19_aux1() + test19_aux2() && test19_aux1() && test19_aux3(&z)) + return z; // no-warning + return 0; +} + +int test23() { + int z; + for ( ; test19_aux1() + test19_aux2() && test19_aux1() && test19_aux3(&z) ; ) + return z; // no-warning + return 0; +} + +// The basic uninitialized value analysis doesn't have enough path-sensitivity +// to catch initializations relying on control-dependencies spanning multiple +// conditionals. This possibly can be handled by making the CFG itself +// represent such control-dependencies, but it is a niche case. +int test24(int flag) { + unsigned val; // expected-note{{initialize the variable 'val' to silence this warning}} + if (flag) + val = 1; + if (!flag) + val = 1; + return val; // expected-warning{{variable 'val' may be uninitialized when used here}} +} + +float test25() { + float x; // expected-note{{initialize the variable 'x' to silence this warning}} + return x; // expected-warning{{variable 'x' is uninitialized when used here}} +} + +typedef int MyInt; +MyInt test26() { + MyInt x; // expected-note{{initialize the variable 'x' to silence this warning}} + return x; // expected-warning{{variable 'x' is uninitialized when used here}} +} + +// Test handling of sizeof(). +int test27() { + struct test_27 { int x; } *y; + return sizeof(y->x); // no-warning +} + +int test28() { + int len; // expected-note{{initialize the variable 'len' to silence this warning}} + return sizeof(int[len]); // expected-warning{{variable 'len' is uninitialized when used here}} +} + +void test29() { + int x; // expected-note{{initialize the variable 'x' to silence this warning}} + (void) ^{ (void) x; }; // expected-warning{{variable 'x' is uninitialized when captured by block}} +} + +void test30() { + static int x; // no-warning + (void) ^{ (void) x; }; +} + +void test31() { + __block int x; // no-warning + (void) ^{ (void) x; }; +} + +int test32_x; +void test32() { + (void) ^{ (void) test32_x; }; // no-warning +} + +void test_33() { + int x; // no-warning + (void) x; +} + +int test_34() { + int x; // expected-note{{initialize the variable 'x' to silence this warning}} + (void) x; + return x; // expected-warning{{variable 'x' is uninitialized when used here}} +} + +// Test that this case doesn't crash. +void test35(int x) { + __block int y = 0; + ^{ y = (x == 0); }(); +} + +// Test handling of indirect goto. +void test36() +{ + void **pc; // expected-note{{initialize the variable 'pc' to silence this warning}} + void *dummy[] = { &&L1, &&L2 }; + L1: + goto *pc; // expected-warning{{variable 'pc' is uninitialized when used here}} + L2: + goto *pc; +} + +// Test && nested in ||. +int test37_a(); +int test37_b(); +int test37() +{ + int identifier; + if ((test37_a() && (identifier = 1)) || + (test37_b() && (identifier = 2))) { + return identifier; // no-warning + } + return 0; +} + +// Test merging of path-specific dataflow values (without asserting). +int test38(int r, int x, int y) +{ + int z; + return ((r < 0) || ((r == 0) && (x < y))); +} + +int test39(int x) { + int y; // expected-note{{initialize the variable 'y' to silence this warning}} + int z = x + y; // expected-warning {{variable 'y' is uninitialized when used here}} + return z; +} + + +int test40(int x) { + int y; // expected-note{{initialize the variable 'y' to silence this warning}} + return x ? 1 : y; // expected-warning {{variable 'y' is uninitialized when used here}} +} + +int test41(int x) { + int y; // expected-note{{initialize the variable 'y' to silence this warning}} + if (x) y = 1; // no-warning + return y; // expected-warning {{variable 'y' may be uninitialized when used here}} +} + +void test42() { + int a; + a = 30; // no-warning +} + +void test43_aux(int x); +void test43(int i) { + int x; // expected-note{{initialize the variable 'x' to silence this warning}} + for (i = 0 ; i < 10; i++) + test43_aux(x++); // expected-warning {{variable 'x' is uninitialized when used here}} +} + +void test44(int i) { + int x = i; + int y; // expected-note{{initialize the variable 'y' to silence this warning}} + for (i = 0; i < 10; i++ ) { + test43_aux(x++); // no-warning + x += y; // expected-warning {{variable 'y' is uninitialized when used here}} + } +} + +int test45(int j) { + int x = 1, y = x + 1; + if (y) // no-warning + return x; + return y; +} + +void test46() +{ + int i; // expected-note{{initialize the variable 'i' to silence this warning}} + int j = i ? : 1; // expected-warning {{variable 'i' is uninitialized when used here}} +} + +void *test47(int *i) +{ + return i ? : 0; // no-warning +} + +void *test49(int *i) +{ + int a; + return &a ? : i; // no-warning +} + +void test50() +{ + char c[1 ? : 2]; // no-warning +} + +int test51(void) +{ + __block int a; + ^(void) { + a = 42; + }(); + return a; // no-warning +} + +// FIXME: This is a false positive, but it tests logical operations in switch statements. +int test52(int a, int b) { + int x; // expected-note {{initialize the variable 'x' to silence this warning}} + switch (a || b) { // expected-warning {{switch condition has boolean value}} + case 0: + x = 1; + break; + case 1: + x = 2; + break; + } + return x; // expected-warning {{variable 'x' may be uninitialized when used here}} +} + +void test53() { + int x; // expected-note {{initialize the variable 'x' to silence this warning}} + int y = (x); // expected-warning {{variable 'x' is uninitialized when used here}} +} + +// This CFG caused the uninitialized values warning to inf-loop. +extern int PR10379_g(); +void PR10379_f(int *len) { + int new_len; // expected-note{{initialize the variable 'new_len' to silence this warning}} + for (int i = 0; i < 42 && PR10379_g() == 0; i++) { + if (PR10379_g() == 1) + continue; + if (PR10379_g() == 2) + PR10379_f(&new_len); + else if (PR10379_g() == 3) + PR10379_f(&new_len); + *len += new_len; // expected-warning {{variable 'new_len' may be uninitialized when used here}} + } +} + +// Test that sizeof(VLA) doesn't trigger a warning. +void test_vla_sizeof(int x) { + double (*memory)[2][x] = malloc(sizeof(*memory)); // no-warning +} + +// Test absurd case of deadcode + use of blocks. This previously was a false positive +// due to an analysis bug. +int test_block_and_dead_code() { + __block int x; + ^{ x = 1; }(); + if (0) + return x; + return x; // no-warning +} + +// This previously triggered an infinite loop in the analysis. +void PR11069(int a, int b) { + unsigned long flags; + for (;;) { + if (a && !b) + break; + } + for (;;) { + // This does not trigger a warning because it isn't a real use. + (void)(flags); // no-warning + } +} + +// Test uninitialized value used in loop condition. +void rdar9432305(float *P) { + int i; // expected-note {{initialize the variable 'i' to silence this warning}} + for (; i < 10000; ++i) // expected-warning {{variable 'i' is uninitialized when used here}} + P[i] = 0.0f; +} diff --git a/clang/test/Sema/unnamed-bitfield-init.c b/clang/test/Sema/unnamed-bitfield-init.c new file mode 100644 index 0000000..f3cc49c --- /dev/null +++ b/clang/test/Sema/unnamed-bitfield-init.c @@ -0,0 +1,6 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +typedef struct { + int a; int : 24; char b; +} S; + +S a = { 1, 2 }; diff --git a/clang/test/Sema/unused-expr-system-header.c b/clang/test/Sema/unused-expr-system-header.c new file mode 100644 index 0000000..dcc8918 --- /dev/null +++ b/clang/test/Sema/unused-expr-system-header.c @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -isystem %S/Inputs -fsyntax-only -verify %s +#include <unused-expr-system-header.h> +void f(int i1, int i2) { + POSSIBLY_BAD_MACRO(5); + STATEMENT_EXPR_MACRO(5); + COMMA_MACRO_1(i1 == i2, f(i1, i2)); // expected-warning {{expression result unused}} + COMMA_MACRO_2(i1 == i2, f(i1, i2)); + COMMA_MACRO_3(i1 == i2, f(i1, i2)); // expected-warning {{expression result unused}} + COMMA_MACRO_4(i1 == i2, f(i1, i2)); +} diff --git a/clang/test/Sema/unused-expr.c b/clang/test/Sema/unused-expr.c new file mode 100644 index 0000000..9761116 --- /dev/null +++ b/clang/test/Sema/unused-expr.c @@ -0,0 +1,123 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -Wno-unreachable-code + +int foo(int X, int Y); + +double sqrt(double X); // implicitly const because of no -fmath-errno! + +void bar(volatile int *VP, int *P, int A, + _Complex double C, volatile _Complex double VC) { + + VP < P; // expected-warning {{expression result unused}} + (void)A; + (void)foo(1,2); // no warning. + + A < foo(1, 2); // expected-warning {{expression result unused}} + + foo(1,2)+foo(4,3); // expected-warning {{expression result unused}} + + + *P; // expected-warning {{expression result unused}} + *VP; // no warning. + P[4]; // expected-warning {{expression result unused}} + VP[4]; // no warning. + + __real__ C; // expected-warning {{expression result unused}} + __real__ VC; + + // We know this can't change errno because of no -fmath-errno. + sqrt(A); // expected-warning {{ignoring return value of function declared with const attribute}} +} + +extern void t1(); +extern void t2(); +void t3(int c) { + c ? t1() : t2(); +} + +// This shouldn't warn: the expr at the end of the stmtexpr really is used. +int stmt_expr(int x, int y) { + return ({int _a = x, _b = y; _a > _b ? _a : _b; }); +} + +void nowarn(unsigned char* a, unsigned char* b) +{ + unsigned char c = 1; + *a |= c, *b += c; + + + // PR4633 + int y, x; + ((void)0), y = x; +} + +void t4(int a) { + int b = 0; + + if (a) + b < 1; // expected-warning{{expression result unused}} + else + b < 2; // expected-warning{{expression result unused}} + + while (1) + b < 3; // expected-warning{{expression result unused}} + + do + b < 4; // expected-warning{{expression result unused}} + while (1); + + for (;;) + b < 5; // expected-warning{{expression result unused}} + + for (b < 1;;) {} // expected-warning{{expression result unused}} + for (;b < 1;) {} + for (;;b < 1) {} // expected-warning{{expression result unused}} +} + +// rdar://7186119 +int t5f(void) __attribute__((warn_unused_result)); +void t5() { + t5f(); // expected-warning {{ignoring return value of function declared with warn_unused_result}} +} + + +int fn1() __attribute__ ((warn_unused_result)); +int fn2() __attribute__ ((pure)); +int fn3() __attribute__ ((const)); +// rdar://6587766 +int t6() { + if (fn1() < 0 || fn2(2,1) < 0 || fn3(2) < 0) // no warnings + return -1; + + fn1(); // expected-warning {{ignoring return value of function declared with warn_unused_result attribute}} + fn2(92, 21); // expected-warning {{ignoring return value of function declared with pure attribute}} + fn3(42); // expected-warning {{ignoring return value of function declared with const attribute}} + __builtin_fabsf(0); // expected-warning {{ignoring return value of function declared with const attribute}} + return 0; +} + +int t7 __attribute__ ((warn_unused_result)); // expected-warning {{'warn_unused_result' attribute only applies to functions}} + +// PR4010 +int (*fn4)(void) __attribute__ ((warn_unused_result)); +void t8() { + fn4(); // expected-warning {{ignoring return value of function declared with warn_unused_result attribute}} +} + +void t9() __attribute__((warn_unused_result)); // expected-warning {{attribute 'warn_unused_result' cannot be applied to functions without return value}} + +// rdar://7410924 +void *some_function(void); +void t10() { + (void*) some_function(); //expected-warning {{expression result unused; should this cast be to 'void'?}} +} + +void f(int i, ...) { + __builtin_va_list ap; + + __builtin_va_start(ap, i); + __builtin_va_arg(ap, int); + __builtin_va_end(ap); +} + +// PR8371 +int fn5() __attribute__ ((__const)); diff --git a/clang/test/Sema/usual-float.c b/clang/test/Sema/usual-float.c new file mode 100644 index 0000000..5a9ab34 --- /dev/null +++ b/clang/test/Sema/usual-float.c @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 %s -fsyntax-only + +typedef float CGFloat; + +extern void func(CGFloat); +void foo(int dir, int n, int tindex) { + const float PI = 3.142; + CGFloat cgf = 3.4; + + float ang = (float) tindex * (-dir*2.0f*PI/n); + func((CGFloat)cgf/65535.0f); +} diff --git a/clang/test/Sema/va_arg_x86_32.c b/clang/test/Sema/va_arg_x86_32.c new file mode 100644 index 0000000..e49f0a4 --- /dev/null +++ b/clang/test/Sema/va_arg_x86_32.c @@ -0,0 +1,6 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -triple=i686-pc-linux-gnu %s + +int a() { + __builtin_va_arg((char*)0, int); // expected-error {{expression is not assignable}} + __builtin_va_arg((void*){0}, int); // expected-error {{first argument to 'va_arg' is of type 'void *'}} +} diff --git a/clang/test/Sema/va_arg_x86_64.c b/clang/test/Sema/va_arg_x86_64.c new file mode 100644 index 0000000..9f514c1 --- /dev/null +++ b/clang/test/Sema/va_arg_x86_64.c @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -triple=x86_64-unknown-freebsd7.0 %s + +// PR2631 +char* foo(char *fmt, __builtin_va_list ap) +{ + return __builtin_va_arg((ap), char *); +} + +// PR2692 +typedef __builtin_va_list va_list; +static void f (char * (*g) (char **, int), char **p, ...) { + char *s; + va_list v; + s = g (p, __builtin_va_arg(v, int)); +} diff --git a/clang/test/Sema/var-redecl.c b/clang/test/Sema/var-redecl.c new file mode 100644 index 0000000..f7576b6 --- /dev/null +++ b/clang/test/Sema/var-redecl.c @@ -0,0 +1,62 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +int outer1; // expected-note{{previous definition is here}} +extern int outer2; // expected-note{{previous definition is here}} +int outer4; +int outer4; // expected-note{{previous definition is here}} +int outer5; +int outer6(float); // expected-note{{previous definition is here}} +int outer7(float); + +void outer_test() { + extern float outer1; // expected-error{{redefinition of 'outer1' with a different type}} + extern float outer2; // expected-error{{redefinition of 'outer2' with a different type}} + extern float outer3; // expected-note{{previous definition is here}} + double outer4; + extern int outer5; // expected-note{{previous definition is here}} + extern int outer6; // expected-error{{redefinition of 'outer6' as different kind of symbol}} + int outer7; + extern int outer8; // expected-note{{previous definition is here}} + extern int outer9; + { + extern int outer9; // expected-note{{previous definition is here}} + } +} + +int outer3; // expected-error{{redefinition of 'outer3' with a different type}} +float outer4; // expected-error{{redefinition of 'outer4' with a different type}} +float outer5; // expected-error{{redefinition of 'outer5' with a different type}} +int outer8(int); // expected-error{{redefinition of 'outer8' as different kind of symbol}} +float outer9; // expected-error{{redefinition of 'outer9' with a different type}} + +extern int outer13; // expected-note{{previous definition is here}} +void outer_shadowing_test() { + extern int outer10; + extern int outer11; // expected-note{{previous definition is here}} + extern int outer12; // expected-note{{previous definition is here}} + { + float outer10; + float outer11; + float outer12; + { + extern int outer10; // okay + extern float outer11; // expected-error{{redefinition of 'outer11' with a different type}} + static double outer12; + { + extern float outer12; // expected-error{{redefinition of 'outer12' with a different type}} + extern float outer13; // expected-error{{redefinition of 'outer13' with a different type}} + } + } + } +} + +void g18(void) { // expected-note{{'g18' declared here}} + extern int g19; +} +int *p=&g19; // expected-error{{use of undeclared identifier 'g19'}} \ + // expected-warning{{incompatible pointer types}} + +// PR3645 +static int a; +extern int a; // expected-note {{previous definition is here}} +int a; // expected-error {{non-static declaration of 'a' follows static declaration}} diff --git a/clang/test/Sema/varargs-x86-64.c b/clang/test/Sema/varargs-x86-64.c new file mode 100644 index 0000000..2fe9b10 --- /dev/null +++ b/clang/test/Sema/varargs-x86-64.c @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -triple x86_64-apple-darwin9 + +// rdar://6726818 +void f1() { + const __builtin_va_list args2; + (void)__builtin_va_arg(args2, int); // expected-error {{first argument to 'va_arg' is of type 'const __builtin_va_list' and not 'va_list'}} +} + diff --git a/clang/test/Sema/varargs.c b/clang/test/Sema/varargs.c new file mode 100644 index 0000000..07081ed --- /dev/null +++ b/clang/test/Sema/varargs.c @@ -0,0 +1,78 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify %s -triple x86_64-apple-darwin9 + +void f1(int a) +{ + __builtin_va_list ap; + + __builtin_va_start(ap, a, a); // expected-error {{too many arguments to function}} + __builtin_va_start(ap, a); // expected-error {{'va_start' used in function with fixed args}} +} + +void f2(int a, int b, ...) +{ + __builtin_va_list ap; + + __builtin_va_start(ap, 10); // expected-warning {{second parameter of 'va_start' not last named argument}} + __builtin_va_start(ap, a); // expected-warning {{second parameter of 'va_start' not last named argument}} + __builtin_va_start(ap, b); +} + +void f3(float a, ...) +{ + __builtin_va_list ap; + + __builtin_va_start(ap, a); + __builtin_va_start(ap, (a)); +} + + +// stdarg: PR3075 +void f4(const char *msg, ...) { + __builtin_va_list ap; + __builtin_stdarg_start((ap), (msg)); + __builtin_va_end (ap); +} + +void f5() { + __builtin_va_list ap; + __builtin_va_start(ap,ap); // expected-error {{'va_start' used in function with fixed args}} +} + +void f6(int a, ...) { + __builtin_va_list ap; + __builtin_va_start(ap); // expected-error {{too few arguments to function}} +} + +// PR3350 +void +foo(__builtin_va_list authors, ...) { + __builtin_va_start (authors, authors); + (void)__builtin_va_arg(authors, int); + __builtin_va_end (authors); +} + +void f7(int a, ...) { + __builtin_va_list ap; + __builtin_va_start(ap, a); + // FIXME: This error message is sub-par. + __builtin_va_arg(ap, int) = 1; // expected-error {{expression is not assignable}} + int *x = &__builtin_va_arg(ap, int); // expected-error {{address expression must be an lvalue or a function designator}} + __builtin_va_end(ap); +} + +void f8(int a, ...) { + __builtin_va_list ap; + __builtin_va_start(ap, a); + (void)__builtin_va_arg(ap, void); // expected-error {{second argument to 'va_arg' is of incomplete type 'void'}} + __builtin_va_end(ap); +} + +enum E { x = -1, y = 2, z = 10000 }; +void f9(__builtin_va_list args) +{ + (void)__builtin_va_arg(args, float); // expected-warning {{second argument to 'va_arg' is of promotable type 'float'}} + (void)__builtin_va_arg(args, enum E); // Don't warn here in C + (void)__builtin_va_arg(args, short); // expected-warning {{second argument to 'va_arg' is of promotable type 'short'}} + (void)__builtin_va_arg(args, char); // expected-warning {{second argument to 'va_arg' is of promotable type 'char'}} +} diff --git a/clang/test/Sema/variadic-block.c b/clang/test/Sema/variadic-block.c new file mode 100644 index 0000000..ba4bb71 --- /dev/null +++ b/clang/test/Sema/variadic-block.c @@ -0,0 +1,41 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only -fblocks + +#include <stdarg.h> + +int main(int argc, char *argv[]) { + + long (^addthem)(const char *, ...) = ^long (const char *format, ...){ + va_list argp; + const char *p; + int i; + char c; + double d; + long result = 0; + va_start(argp, format); + for (p = format; *p; p++) switch (*p) { + case 'i': + i = va_arg(argp, int); + result += i; + break; + case 'd': + d = va_arg(argp, double); + result += (int)d; + break; + case 'c': + c = va_arg(argp, int); + result += c; + break; + } + return result; + }; + long testresult = addthem("ii", 10, 20); + if (testresult != 30) { + return 1; + } + testresult = addthem("idc", 30, 40.0, 'a'); + if (testresult != (70+'a')) { + return 1; + } + return 0; +} + diff --git a/clang/test/Sema/variadic-incomplete-arg-type.c b/clang/test/Sema/variadic-incomplete-arg-type.c new file mode 100644 index 0000000..2b5dd1a --- /dev/null +++ b/clang/test/Sema/variadic-incomplete-arg-type.c @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify +// rdar://10961370 + +typedef struct __CFError * CFErrorRef; // expected-note {{forward declaration of 'struct __CFError'}} + +void junk(int, ...); + +int main() +{ + CFErrorRef error; + junk(1, *error, (void)0); // expected-error {{argument type 'struct __CFError' is incomplete}} \ + // expected-error {{argument type 'void' is incomplete}} +} diff --git a/clang/test/Sema/vector-assign.c b/clang/test/Sema/vector-assign.c new file mode 100644 index 0000000..f01eb45 --- /dev/null +++ b/clang/test/Sema/vector-assign.c @@ -0,0 +1,53 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only -Wvector-conversion +typedef unsigned int v2u __attribute__ ((vector_size (8))); +typedef signed int v2s __attribute__ ((vector_size (8))); +typedef signed int v1s __attribute__ ((vector_size (4))); +typedef float v2f __attribute__ ((vector_size(8))); +typedef signed short v4ss __attribute__ ((vector_size (8))); + +void test1() { + v2s v1; + v2u v2; + v1s v3; + v2f v4; + v4ss v5; + + v1 = v2; // expected-warning {{incompatible vector types assigning to 'v2s' from 'v2u'}} + v1 = v3; // expected-error {{assigning to 'v2s' from incompatible type 'v1s'}} + v1 = v4; // expected-warning {{incompatible vector types assigning to 'v2s' from 'v2f'}} + v1 = v5; // expected-warning {{incompatible vector types assigning to 'v2s' from 'v4ss'}} + + v2 = v1; // expected-warning {{incompatible vector types assigning to 'v2u' from 'v2s'}} + v2 = v3; // expected-error {{assigning to 'v2u' from incompatible type 'v1s'}} + v2 = v4; // expected-warning {{incompatible vector types assigning to 'v2u' from 'v2f'}} + v2 = v5; // expected-warning {{incompatible vector types assigning to 'v2u' from 'v4ss'}} + + v3 = v1; // expected-error {{assigning to 'v1s' from incompatible type 'v2s'}} + v3 = v2; // expected-error {{assigning to 'v1s' from incompatible type 'v2u'}} + v3 = v4; // expected-error {{assigning to 'v1s' from incompatible type 'v2f'}} + v3 = v5; // expected-error {{assigning to 'v1s' from incompatible type 'v4ss'}} + + v4 = v1; // expected-warning {{incompatible vector types assigning to 'v2f' from 'v2s'}} + v4 = v2; // expected-warning {{incompatible vector types assigning to 'v2f' from 'v2u'}} + v4 = v3; // expected-error {{assigning to 'v2f' from incompatible type 'v1s'}} + v4 = v5; // expected-warning {{incompatible vector types assigning to 'v2f' from 'v4ss'}} + + v5 = v1; // expected-warning {{incompatible vector types assigning to 'v4ss' from 'v2s'}} + v5 = v2; // expected-warning {{incompatible vector types assigning to 'v4ss' from 'v2u'}} + v5 = v3; // expected-error {{assigning to 'v4ss' from incompatible type 'v1s'}} + v5 = v4; // expected-warning {{incompatible vector types assigning to 'v4ss' from 'v2f'}} +} + +// PR2263 +float test2(__attribute__((vector_size(16))) float a, int b) { + return a[b]; +} + +// PR4838 +typedef long long __attribute__((__vector_size__(2 * sizeof(long long)))) +longlongvec; + +void test3a(longlongvec *); // expected-note{{passing argument to parameter here}} +void test3(const unsigned *src) { + test3a(src); // expected-warning {{incompatible pointer types passing 'const unsigned int *' to parameter of type 'longlongvec *'}} +} diff --git a/clang/test/Sema/vector-cast.c b/clang/test/Sema/vector-cast.c new file mode 100644 index 0000000..f1cf013 --- /dev/null +++ b/clang/test/Sema/vector-cast.c @@ -0,0 +1,38 @@ +// RUN: %clang_cc1 -fsyntax-only %s -verify -Wvector-conversion + +typedef long long t1 __attribute__ ((vector_size (8))); +typedef char t2 __attribute__ ((vector_size (16))); +typedef float t3 __attribute__ ((vector_size (16))); + +void f() +{ + t1 v1; + t2 v2; + t3 v3; + + v2 = (t2)v1; // -expected-error {{invalid conversion between vector type \ +'t2' and 't1' of different size}} + v1 = (t1)v2; // -expected-error {{invalid conversion between vector type \ +'t1' and 't2' of different size}} + v3 = (t3)v2; + + v1 = (t1)(char *)10; // -expected-error {{invalid conversion between vector \ +type 't1' and scalar type 'char *'}} + v1 = (t1)(long long)10; + v1 = (t1)(short)10; // -expected-error {{invalid conversion between vector \ +type 't1' and integer type 'short' of different size}} + + long long r1 = (long long)v1; + short r2 = (short)v1; // -expected-error {{invalid conversion between vector \ +type 't1' and integer type 'short' of different size}} + char *r3 = (char *)v1; // -expected-error {{invalid conversion between vector\ + type 't1' and scalar type 'char *'}} +} + + +void f2(t2 X); // expected-note{{passing argument to parameter 'X' here}} + +void f3(t3 Y) { + f2(Y); // expected-warning {{incompatible vector types passing 't3' to parameter of type 't2'}} +} + diff --git a/clang/test/Sema/vector-init.c b/clang/test/Sema/vector-init.c new file mode 100644 index 0000000..5be040a --- /dev/null +++ b/clang/test/Sema/vector-init.c @@ -0,0 +1,44 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify + +//typedef __attribute__(( ext_vector_type(4) )) float float4; +typedef float float4 __attribute__((vector_size(16))); + +float4 foo = (float4){ 1.0, 2.0, 3.0, 4.0 }; + +float4 foo2 = (float4){ 1.0, 2.0, 3.0, 4.0 , 5.0 }; // expected-warning{{excess elements in vector initializer}} + +float4 array[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0}; +int array_sizecheck[(sizeof(array) / sizeof(float4)) == 3 ? 1 : -1]; + +float4 array2[2] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, + 9.0 }; // expected-warning {{excess elements in array initializer}} + +float4 array3[2] = { {1.0, 2.0, 3.0}, 5.0, 6.0, 7.0, 8.0, + 9.0 }; // expected-warning {{excess elements in array initializer}} + +// PR5650 +__attribute__((vector_size(16))) float f1(void) { + __attribute__((vector_size(16))) float vec = {0.0f, 0.0f, 0.0f}; + return(vec); +} + +__attribute__((vector_size(16))) float f2( + __attribute__((vector_size(16))) float a1) { + return(a1); +} + + + +// PR5265 +typedef float __attribute__((ext_vector_type (3))) float3; +int test2[sizeof(float3) == sizeof(float4) ? 1 : -1]; + +// rdar://problem/8345836 +typedef long long __attribute__((vector_size(16))) longlong2; +typedef short __attribute__((vector_size(16))) short8; +typedef short __attribute__((vector_size(8))) short4; +void test3() { + extern short8 test3_helper(void); + longlong2 arr1[2] = { test3_helper(), test3_helper() }; + short4 arr2[2] = { test3_helper(), test3_helper() }; // expected-error 2 {{initializing 'short4' with an expression of incompatible type 'short8'}} +} diff --git a/clang/test/Sema/vector-ops.c b/clang/test/Sema/vector-ops.c new file mode 100644 index 0000000..3ab75d0 --- /dev/null +++ b/clang/test/Sema/vector-ops.c @@ -0,0 +1,29 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only -Wvector-conversion +typedef unsigned int v2u __attribute__ ((vector_size (8))); +typedef int v2s __attribute__ ((vector_size (8))); +typedef float v2f __attribute__ ((vector_size(8))); + +void test1(v2u v2ua, v2s v2sa, v2f v2fa) { + // Bitwise binary operators + (void)(v2ua & v2ua); + (void)(v2fa & v2fa); // expected-error{{invalid operands to binary expression}} + + // Unary operators + (void)(~v2ua); + (void)(~v2fa); // expected-error{{invalid argument type 'v2f' to unary}} + + // Comparison operators + v2ua = (v2ua==v2sa); // expected-warning{{incompatible vector types assigning to 'v2u' from 'int __attribute__((ext_vector_type(2)))'}} + v2sa = (v2ua==v2sa); + + // Arrays + int array1[v2ua]; // expected-error{{size of array has non-integer type 'v2u'}} + int array2[17]; + // FIXME: error message below needs type! + (void)(array2[v2ua]); // expected-error{{array subscript is not an integer}} + + v2u *v2u_ptr = 0; + v2s *v2s_ptr; + v2s_ptr = v2u_ptr; // expected-warning{{converts between pointers to integer types with different sign}} +} + diff --git a/clang/test/Sema/vfprintf-invalid-redecl.c b/clang/test/Sema/vfprintf-invalid-redecl.c new file mode 100644 index 0000000..cbf47a6 --- /dev/null +++ b/clang/test/Sema/vfprintf-invalid-redecl.c @@ -0,0 +1,6 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify +// PR4290 + +// The following declaration is not compatible with vfprintf(), but make +// sure this isn't an error: autoconf expects this to build. +char vfprintf(); // expected-warning {{incompatible redeclaration of library function 'vfprintf'}} expected-note {{'vfprintf' is a builtin}} diff --git a/clang/test/Sema/vfprintf-valid-redecl.c b/clang/test/Sema/vfprintf-valid-redecl.c new file mode 100644 index 0000000..14fbbc4 --- /dev/null +++ b/clang/test/Sema/vfprintf-valid-redecl.c @@ -0,0 +1,6 @@ +// RUN: %clang_cc1 %s -fsyntax-only -pedantic -verify +// PR4290 + +// The following declaration is compatible with vfprintf, so we shouldn't +// warn. +int vfprintf(); diff --git a/clang/test/Sema/vla-2.c b/clang/test/Sema/vla-2.c new file mode 100644 index 0000000..819cab9 --- /dev/null +++ b/clang/test/Sema/vla-2.c @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only -pedantic +// Check that we don't crash trying to emit warnings in a potentially-evaluated +// sizeof or typeof. (This test needs to be in a separate file because we use +// a different codepath when we have already emitted an error.) + +int PotentiallyEvaluatedSizeofWarn(int n) { + return (int)sizeof *(0 << 32,(int(*)[n])0); // expected-warning {{expression result unused}} expected-warning {{shift count >= width of type}} +} + +void PotentiallyEvaluatedTypeofWarn(int n) { + __typeof(*(0 << 32,(int(*)[n])0)) x; // expected-warning {{expression result unused}} expected-warning {{shift count >= width of type}} + (void)x; +} + +void PotentiallyEvaluatedArrayBoundWarn(int n) { + (void)*(int(*)[(0 << 32,n)])0; // FIXME: We should warn here. +} diff --git a/clang/test/Sema/vla.c b/clang/test/Sema/vla.c new file mode 100644 index 0000000..4fd6361 --- /dev/null +++ b/clang/test/Sema/vla.c @@ -0,0 +1,67 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only -pedantic + +int test1() { + typedef int x[test1()]; // vla + static int y = sizeof(x); // expected-error {{not a compile-time constant}} +} + +// PR2347 +void f (unsigned int m) +{ + int e[2][m]; + + e[0][0] = 0; +} + +// PR3048 +int x = sizeof(struct{char qq[x];}); // expected-error {{fields must have a constant size}} + +// PR2352 +void f2(unsigned int m) +{ + extern int e1[2][m]; // expected-error {{variable length array declaration can not have 'extern' linkage}} + + e1[0][0] = 0; + +} + +// PR2361 +int i; +int c[][i]; // expected-error {{variably modified type declaration not allowed at file scope}} +int d[i]; // expected-error {{variable length array declaration not allowed at file scope}} + +int (*e)[i]; // expected-error {{variably modified type declaration not allowed at file scope}} + +void f3() +{ + static int a[i]; // expected-error {{variable length array declaration can not have 'static' storage duration}} + extern int b[i]; // expected-error {{variable length array declaration can not have 'extern' linkage}} + + extern int (*c1)[i]; // expected-error {{variably modified type declaration can not have 'extern' linkage}} + static int (*d)[i]; +} + +// PR3663 +static const unsigned array[((2 * (int)((((4) / 2) + 1.0/3.0) * (4) - 1e-8)) + 1)]; // expected-warning {{variable length array folded to constant array as an extension}} + +int a[*]; // expected-error {{star modifier used outside of function prototype}} +int f4(int a[*][*]); + +// PR2044 +int pr2044(int b) {int (*c(void))[b];**c() = 2;} // expected-error {{variably modified type}} +int pr2044b; +int (*pr2044c(void))[pr2044b]; // expected-error {{variably modified type}} + +const int f5_ci = 1; +void f5() { char a[][f5_ci] = {""}; } // expected-warning {{variable length array folded to constant array as an extension}} + +// PR5185 +void pr5185(int a[*]); +void pr5185(int a[*]) // expected-error {{variable length array must be bound in function definition}} +{ +} + +// Make sure this isn't treated as an error +int TransformBug(int a) { + return sizeof(*(int(*)[({ goto v; v: a;})]) 0); // expected-warning {{use of GNU statement expression extension}} +} diff --git a/clang/test/Sema/void_arg.c b/clang/test/Sema/void_arg.c new file mode 100644 index 0000000..337972f --- /dev/null +++ b/clang/test/Sema/void_arg.c @@ -0,0 +1,26 @@ +/* RUN: %clang_cc1 -fsyntax-only %s -verify + */ + +typedef void Void; + +void foo() { + int X; + + X = sizeof(int (void a)); // expected-error {{argument may not have 'void' type}} + X = sizeof(int (int, void)); // expected-error {{must be the first and only parameter}} + X = sizeof(int (void, ...)); // expected-error {{must be the first and only parameter}} + + X = sizeof(int (Void a)); // expected-error {{argument may not have 'void' type}} + X = sizeof(int (int, Void)); // expected-error {{must be the first and only parameter}} + X = sizeof(int (Void, ...)); // expected-error {{must be the first and only parameter}} + + // Accept these. + X = sizeof(int (void)); + X = sizeof(int (Void)); +} + +// this is ok. +void bar(Void) { +} + +void f(const void); // expected-error {{parameter must not have type qualifiers}} diff --git a/clang/test/Sema/warn-cast-align.c b/clang/test/Sema/warn-cast-align.c new file mode 100644 index 0000000..9d64699 --- /dev/null +++ b/clang/test/Sema/warn-cast-align.c @@ -0,0 +1,41 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -Wcast-align -verify %s + +// Simple casts. +void test0(char *P) { + char *a = (char*) P; + short *b = (short*) P; // expected-warning {{cast from 'char *' to 'short *' increases required alignment from 1 to 2}} + int *c = (int*) P; // expected-warning {{cast from 'char *' to 'int *' increases required alignment from 1 to 4}} +} + +// Casts from void* are a special case. +void test1(void *P) { + char *a = (char*) P; + short *b = (short*) P; + int *c = (int*) P; + + const volatile void *P2 = P; + char *d = (char*) P2; + short *e = (short*) P2; + int *f = (int*) P2; + + const char *g = (const char*) P2; + const short *h = (const short*) P2; + const int *i = (const int*) P2; + + const volatile char *j = (const volatile char*) P2; + const volatile short *k = (const volatile short*) P2; + const volatile int *l = (const volatile int*) P2; +} + +// Aligned struct. +struct __attribute__((aligned(16))) A { + char buffer[16]; +}; +void test2(char *P) { + struct A *a = (struct A*) P; // expected-warning {{cast from 'char *' to 'struct A *' increases required alignment from 1 to 16}} +} + +// Incomplete type. +void test3(char *P) { + struct B *b = (struct B*) P; +} diff --git a/clang/test/Sema/warn-char-subscripts.c b/clang/test/Sema/warn-char-subscripts.c new file mode 100644 index 0000000..374a609 --- /dev/null +++ b/clang/test/Sema/warn-char-subscripts.c @@ -0,0 +1,64 @@ +// RUN: %clang_cc1 -Wchar-subscripts -fsyntax-only -verify %s + +void t1() { + int array[1] = { 0 }; + char subscript = 0; + int val = array[subscript]; // expected-warning{{array subscript is of type 'char'}} +} + +void t2() { + int array[1] = { 0 }; + char subscript = 0; + int val = subscript[array]; // expected-warning{{array subscript is of type 'char'}} +} + +void t3() { + int *array = 0; + char subscript = 0; + int val = array[subscript]; // expected-warning{{array subscript is of type 'char'}} +} + +void t4() { + int *array = 0; + char subscript = 0; + int val = subscript[array]; // expected-warning{{array subscript is of type 'char'}} +} + +char returnsChar(); +void t5() { + int *array = 0; + int val = array[returnsChar()]; // expected-warning{{array subscript is of type 'char'}} +} + +void t6() { + int array[1] = { 0 }; + signed char subscript = 0; + int val = array[subscript]; // no warning for explicit signed char +} + +void t7() { + int array[1] = { 0 }; + unsigned char subscript = 0; + int val = array[subscript]; // no warning for unsigned char +} + +typedef char CharTy; +void t8() { + int array[1] = { 0 }; + CharTy subscript = 0; + int val = array[subscript]; // expected-warning{{array subscript is of type 'char'}} +} + +typedef signed char SignedCharTy; +void t9() { + int array[1] = { 0 }; + SignedCharTy subscript = 0; + int val = array[subscript]; // no warning for explicit signed char +} + +typedef unsigned char UnsignedCharTy; +void t10() { + int array[1] = { 0 }; + UnsignedCharTy subscript = 0; + int val = array[subscript]; // no warning for unsigned char +} diff --git a/clang/test/Sema/warn-freestanding-complex.c b/clang/test/Sema/warn-freestanding-complex.c new file mode 100644 index 0000000..14e063f --- /dev/null +++ b/clang/test/Sema/warn-freestanding-complex.c @@ -0,0 +1,4 @@ +// RUN: %clang_cc1 -fsyntax-only -ffreestanding -pedantic -verify %s + +void foo(float _Complex c) { // expected-warning{{complex numbers are an extension in a freestanding C99 implementation}} +} diff --git a/clang/test/Sema/warn-gnu-designators.c b/clang/test/Sema/warn-gnu-designators.c new file mode 100644 index 0000000..bdb3374 --- /dev/null +++ b/clang/test/Sema/warn-gnu-designators.c @@ -0,0 +1,2 @@ +// RUN: %clang_cc1 -Wno-gnu-designator -verify %s +struct { int x, y, z[12]; } value = { x:17, .z [3 ... 5] = 7 }; diff --git a/clang/test/Sema/warn-missing-braces.c b/clang/test/Sema/warn-missing-braces.c new file mode 100644 index 0000000..ebfe984 --- /dev/null +++ b/clang/test/Sema/warn-missing-braces.c @@ -0,0 +1,3 @@ +// RUN: %clang_cc1 -fsyntax-only -Wmissing-braces -verify %s + +int a[2][2] = { 0, 1, 2, 3 }; // expected-warning{{suggest braces}} expected-warning{{suggest braces}} diff --git a/clang/test/Sema/warn-missing-prototypes.c b/clang/test/Sema/warn-missing-prototypes.c new file mode 100644 index 0000000..bfd1459 --- /dev/null +++ b/clang/test/Sema/warn-missing-prototypes.c @@ -0,0 +1,37 @@ +// RUN: %clang -Wmissing-prototypes -fsyntax-only -Xclang -verify %s + +int f(); + +int f(int x) { return x; } // expected-warning{{no previous prototype for function 'f'}} + +static int g(int x) { return x; } + +int h(int x) { return x; } // expected-warning{{no previous prototype for function 'h'}} + +static int g2(); + +int g2(int x) { return x; } + +void test(void); + +int h3(); +int h4(int); +int h4(); + +void test(void) { + int h2(int x); + int h3(int x); + int h4(); +} + +int h2(int x) { return x; } // expected-warning{{no previous prototype for function 'h2'}} +int h3(int x) { return x; } // expected-warning{{no previous prototype for function 'h3'}} +int h4(int x) { return x; } + +int f2(int); +int f2(); + +int f2(int x) { return x; } + +// rdar://6759522 +int main(void) { return 0; } diff --git a/clang/test/Sema/warn-shadow.c b/clang/test/Sema/warn-shadow.c new file mode 100644 index 0000000..32aca8d --- /dev/null +++ b/clang/test/Sema/warn-shadow.c @@ -0,0 +1,61 @@ +// RUN: %clang_cc1 -verify -fsyntax-only -fblocks -Wshadow %s + +int i; // expected-note 3 {{previous declaration is here}} + +void foo() { + int pass1; + int i; // expected-warning {{declaration shadows a variable in the global scope}} \ + // expected-note {{previous declaration is here}} + { + int pass2; + int i; // expected-warning {{declaration shadows a local variable}} \ + // expected-note {{previous declaration is here}} + { + int pass3; + int i; // expected-warning {{declaration shadows a local variable}} + } + } + + int sin; // okay; 'sin' has not been declared, even though it's a builtin. +} + +// <rdar://problem/7677531> +void (^test1)(int) = ^(int i) { // expected-warning {{declaration shadows a variable in the global scope}} \ + // expected-note{{previous declaration is here}} + { + int i; // expected-warning {{declaration shadows a local variable}} \ + // expected-note{{previous declaration is here}} + + (^(int i) { return i; })(i); //expected-warning {{declaration shadows a local variable}} + } +}; + + +struct test2 { + int i; +}; + +void test3(void) { + struct test4 { + int i; + }; +} + +void test4(int i) { // expected-warning {{declaration shadows a variable in the global scope}} +} + +// Don't warn about shadowing for function declarations. +void test5(int i); +void test6(void (*f)(int i)) {} +void test7(void *context, void (*callback)(void *context)) {} + +extern int bob; // expected-note {{previous declaration is here}} + +// rdar://8883302 +void rdar8883302() { + extern int bob; // don't warn for shadowing. +} + +void test8() { + int bob; // expected-warning {{declaration shadows a variable in the global scope}} +} diff --git a/clang/test/Sema/warn-sizeof-arrayarg.c b/clang/test/Sema/warn-sizeof-arrayarg.c new file mode 100644 index 0000000..ba8a5fa --- /dev/null +++ b/clang/test/Sema/warn-sizeof-arrayarg.c @@ -0,0 +1,30 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +typedef int Arr[10]; + +typedef int trungl_int; + +void f(int a[10], Arr arr) { // \ +// expected-note {{declared here}} \ +// expected-note {{declared here}} \ +// expected-note {{declared here}} \ +// expected-note {{declared here}} + + /* Should warn. */ + (void)sizeof(a); // \ + // expected-warning{{sizeof on array function parameter will return size of 'int *' instead of 'int [10]'}} + (void)sizeof((((a)))); // \ + // expected-warning{{sizeof on array function parameter will return size of 'int *' instead of 'int [10]'}} + (void)sizeof a; // \ + // expected-warning{{sizeof on array function parameter will return size of 'int *' instead of 'int [10]'}} + (void)sizeof arr; // \ + // expected-warning{{sizeof on array function parameter will return size of 'int *' instead of 'Arr' (aka 'int [10]')}} + + /* Shouldn't warn. */ + int b[10]; + (void)sizeof b; + Arr brr; + (void)sizeof brr; + (void)sizeof(Arr); + (void)sizeof(int); +} diff --git a/clang/test/Sema/warn-strlcpycat-size.c b/clang/test/Sema/warn-strlcpycat-size.c new file mode 100644 index 0000000..8babdde --- /dev/null +++ b/clang/test/Sema/warn-strlcpycat-size.c @@ -0,0 +1,55 @@ +// RUN: %clang_cc1 -Wstrlcpy-strlcat-size -verify -fsyntax-only %s + +typedef __SIZE_TYPE__ size_t; +size_t strlcpy (char * restrict dst, const char * restrict src, size_t size); +size_t strlcat (char * restrict dst, const char * restrict src, size_t size); +size_t strlen (const char *s); + +char s1[100]; +char s2[200]; +char * s3; + +struct { + char f1[100]; + char f2[100][3]; +} s4, **s5; + +int x; + +void f(void) +{ + strlcpy(s1, s2, sizeof(s1)); // no warning + strlcpy(s1, s2, sizeof(s2)); // expected-warning {{size argument in 'strlcpy' call appears to be size of the source; expected the size of the destination}} expected-note {{change size argument to be the size of the destination}} + strlcpy(s1, s3, strlen(s3)+1); // expected-warning {{size argument in 'strlcpy' call appears to be size of the source; expected the size of the destination}} expected-note {{change size argument to be the size of the destination}} + strlcat(s2, s3, sizeof(s3)); // expected-warning {{size argument in 'strlcat' call appears to be size of the source; expected the size of the destination}} expected-note {{change size argument to be the size of the destination}} + strlcpy(s4.f1, s2, sizeof(s2)); // expected-warning {{size argument in 'strlcpy' call appears to be size of the source; expected the size of the destination}} expected-note {{change size argument to be the size of the destination}} + strlcpy((*s5)->f2[x], s2, sizeof(s2)); // expected-warning {{size argument in 'strlcpy' call appears to be size of the source; expected the size of the destination}} expected-note {{change size argument to be the size of the destination}} + strlcpy(s1+3, s2, sizeof(s2)); // expected-warning {{size argument in 'strlcpy' call appears to be size of the source; expected the size of the destination}} +} + +// Don't issue FIXIT for flexible arrays. +struct S { + int y; + char x[]; +}; + +void flexible_arrays(struct S *s) { + char str[] = "hi"; + strlcpy(s->x, str, sizeof(str)); // expected-warning {{size argument in 'strlcpy' call appears to be size of the source; expected the size of the destination}} +} + +// Don't issue FIXIT for destinations of size 1. +void size_1() { + char z[1]; + char str[] = "hi"; + + strlcpy(z, str, sizeof(str)); // expected-warning {{size argument in 'strlcpy' call appears to be size of the source; expected the size of the destination}} +} + +// Support VLAs. +void vlas(int size) { + char z[size]; + char str[] = "hi"; + + strlcpy(z, str, sizeof(str)); // expected-warning {{size argument in 'strlcpy' call appears to be size of the source; expected the size of the destination}} expected-note {{change size argument to be the size of the destination}} +} diff --git a/clang/test/Sema/warn-strncat-size.c b/clang/test/Sema/warn-strncat-size.c new file mode 100644 index 0000000..7157edf --- /dev/null +++ b/clang/test/Sema/warn-strncat-size.c @@ -0,0 +1,71 @@ +// RUN: %clang_cc1 -Wstrncat-size -verify -fsyntax-only %s +// RUN: %clang_cc1 -DUSE_BUILTINS -Wstrncat-size -verify -fsyntax-only %s +// RUN: %clang_cc1 -fsyntax-only -Wstrncat-size -fixit -x c %s +// RUN: %clang_cc1 -DUSE_BUILTINS -fsyntax-only -Wstrncat-size -fixit -x c %s + +typedef __SIZE_TYPE__ size_t; +size_t strlen (const char *s); + +#ifdef USE_BUILTINS +# define BUILTIN(f) __builtin_ ## f +#else +# define BUILTIN(f) f +#endif + +#define strncat BUILTIN(strncat) +char *strncat(char *restrict s1, const char *restrict s2, size_t n); + +struct { + char f1[100]; + char f2[100][3]; +} s4, **s5; + +char s1[100]; +char s2[200]; +int x; + +void test(char *src) { + char dest[10]; + + strncat(dest, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAA", sizeof(dest) - strlen(dest) - 1); // no-warning + strncat(dest, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAA", sizeof(dest) - 1); // no-warning - the code might assume that dest is empty + + strncat(dest, src, sizeof(src)); // expected-warning {{size argument in 'strncat' call appears to be size of the source}} expected-note {{change the argument to be the free space in the destination buffer minus the terminating null byte}} + + strncat(dest, src, sizeof(src) - 1); // expected-warning {{size argument in 'strncat' call appears to be size of the source}} expected-note {{change the argument to be the free space in the destination buffer minus the terminating null byte}} + + strncat(dest, "AAAAAAAAAAAAAAAAAAAAAAAAAAA", sizeof(dest)); // expected-warning{{the value of the size argument in 'strncat' is too large, might lead to a buffer overflow}} expected-note {{change the argument to be the free space in the destination buffer minus the terminating null byte}} + + strncat(dest, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", sizeof(dest) - strlen(dest)); // expected-warning{{the value of the size argument in 'strncat' is too large, might lead to a buffer overflow}} expected-note {{change the argument to be the free space in the destination buffer minus the terminating null byte}} + + strncat((*s5)->f2[x], s2, sizeof(s2)); // expected-warning {{size argument in 'strncat' call appears to be size of the source}} expected-note {{change the argument to be the free space in the destination buffer minus the terminating null byte}} + strncat(s1+3, s2, sizeof(s2)); // expected-warning {{size argument in 'strncat' call appears to be size of the source}} + strncat(s4.f1, s2, sizeof(s2)); // expected-warning {{size argument in 'strncat' call appears to be size of the source}} expected-note {{change the argument to be the free space in the destination buffer minus the terminating null byte}} +} + +// Don't issue FIXIT for flexible arrays. +struct S { + int y; + char x[]; +}; + +void flexible_arrays(struct S *s) { + char str[] = "hi"; + strncat(s->x, str, sizeof(str)); // expected-warning {{size argument in 'strncat' call appears to be size of the source}} +} + +// Don't issue FIXIT for destinations of size 1. +void size_1() { + char z[1]; + char str[] = "hi"; + + strncat(z, str, sizeof(z)); // expected-warning{{the value of the size argument in 'strncat' is too large, might lead to a buffer overflow}} +} + +// Support VLAs. +void vlas(int size) { + char z[size]; + char str[] = "hi"; + + strncat(z, str, sizeof(str)); // expected-warning {{size argument in 'strncat' call appears to be size of the source}} expected-note {{change the argument to be the free space in the destination buffer minus the terminating null byte}} +} diff --git a/clang/test/Sema/warn-unreachable.c b/clang/test/Sema/warn-unreachable.c new file mode 100644 index 0000000..636513f --- /dev/null +++ b/clang/test/Sema/warn-unreachable.c @@ -0,0 +1,134 @@ +// RUN: %clang %s -fsyntax-only -Xclang -verify -fblocks -Wunreachable-code -Wno-unused-value -Wno-covered-switch-default + +int halt() __attribute__((noreturn)); +int live(); +int dead(); + +void test1() { + goto c; + d: + goto e; // expected-warning {{will never be executed}} + c: ; + int i; + return; + goto b; // expected-warning {{will never be executed}} + goto a; // expected-warning {{will never be executed}} + b: + i = 1; + a: + i = 2; + goto f; + e: + goto d; + f: ; +} + +void test2() { + int i; + switch (live()) { + case 1: + halt(), + dead(); // expected-warning {{will never be executed}} + + case 2: + live(), halt(), + dead(); // expected-warning {{will never be executed}} + + case 3: + live() + + // expected-warning {{will never be executed}} + halt(); + dead(); + + case 4: + a4: + live(), + halt(); + goto a4; // expected-warning {{will never be executed}} + + case 5: + goto a5; + c5: + dead(); // expected-warning {{will never be executed}} + goto b5; + a5: + live(), + halt(); + b5: + goto c5; + + case 6: + if (live()) + goto e6; + live(), + halt(); + d6: + dead(); // expected-warning {{will never be executed}} + goto b6; + c6: + dead(); + goto b6; + e6: + live(), + halt(); + b6: + goto c6; + case 7: + halt() + + + dead(); // expected-warning {{will never be executed}} + - // expected-warning {{will never be executed}} + halt(); + case 8: + i // expected-warning {{will never be executed}} + += + halt(); + case 9: + halt() + ? // expected-warning {{will never be executed}} + dead() : dead(); + case 10: + ( // expected-warning {{will never be executed}} + float)halt(); + case 11: { + int a[5]; + live(), + a[halt() // expected-warning {{will never be executed}} + ]; + } + } +} + +enum Cases { C1, C2, C3 }; +int test_enum_cases(enum Cases C) { + switch (C) { + case C1: + case C2: + case C3: + return 1; + default: { + int i = 0; // expected-warning{{will never be executed}} + ++i; + return i; + } + } +} + +// Handle unreachable code triggered by macro expansions. +void __myassert_rtn(const char *, const char *, int, const char *) __attribute__((__noreturn__)); + +#define myassert(e) \ + (__builtin_expect(!(e), 0) ? __myassert_rtn(__func__, __FILE__, __LINE__, #e) : (void)0) + +void test_assert() { + myassert(0 && "unreachable"); + return; // no-warning +} + +// Test case for PR 9774. Tests that dead code in macros aren't warned about. +#define MY_MAX(a,b) ((a) >= (b) ? (a) : (b)) +void PR9774(int *s) { + for (int i = 0; i < MY_MAX(2, 3); i++) // no-warning + s[i] = 0; +} + diff --git a/clang/test/Sema/warn-unused-function.c b/clang/test/Sema/warn-unused-function.c new file mode 100644 index 0000000..8f4cdcb --- /dev/null +++ b/clang/test/Sema/warn-unused-function.c @@ -0,0 +1,56 @@ +// RUN: %clang_cc1 -fsyntax-only -Wunused-function -Wunneeded-internal-declaration -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify -Wunused %s +// RUN: %clang_cc1 -fsyntax-only -verify -Wall %s + +void foo() {} +static void f2() {} +static void f1() {f2();} // expected-warning{{unused}} + +static int f0() { return 17; } // expected-warning{{not needed and will not be emitted}} +int x = sizeof(f0()); + +static void f3(); +extern void f3() { } // expected-warning{{unused}} + +// FIXME: This will trigger a warning when it should not. +// Update once PR6281 is fixed. +//inline static void f4(); +//void f4() { } + +static void __attribute__((used)) f5() {} +static void f6(); +static void __attribute__((used)) f6(); +static void f6() {}; + +static void f7(void); +void f8(void(*a0)(void)); +void f9(void) { f8(f7); } +static void f7(void) {} + +__attribute__((unused)) static void bar(void); +void bar(void) { } + +__attribute__((constructor)) static void bar2(void); +void bar2(void) { } + +__attribute__((destructor)) static void bar3(void); +void bar3(void) { } + +static void f10(void); // expected-warning{{unused}} +static void f10(void); + +static void f11(void); +static void f11(void) { } // expected-warning{{unused}} + +static void f12(void) { } // expected-warning{{unused}} +static void f12(void); + +// PR7923 +static void unused(void) { unused(); } // expected-warning{{not needed and will not be emitted}} + +// rdar://8728293 +static void cleanupMalloc(char * const * const allocation) { } +void f13(void) { + char * const __attribute__((cleanup(cleanupMalloc))) a; + (void)a; +} diff --git a/clang/test/Sema/warn-unused-label.c b/clang/test/Sema/warn-unused-label.c new file mode 100644 index 0000000..48370a5 --- /dev/null +++ b/clang/test/Sema/warn-unused-label.c @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -fsyntax-only -Wunused-label -verify %s + +void f() { + a: + goto a; + b: // expected-warning{{unused}} + c: __attribute__((unused)); + d: __attribute__((noreturn)); // expected-warning {{'noreturn' attribute only applies to functions}} + goto d; + return; +} diff --git a/clang/test/Sema/warn-unused-parameters.c b/clang/test/Sema/warn-unused-parameters.c new file mode 100644 index 0000000..af048e7 --- /dev/null +++ b/clang/test/Sema/warn-unused-parameters.c @@ -0,0 +1,30 @@ +// RUN: %clang_cc1 -fblocks -fsyntax-only -Wunused-parameter %s 2>&1 | FileCheck %s +// RUN: %clang_cc1 -fblocks -fsyntax-only -Wunused %s 2>&1 | FileCheck -check-prefix=CHECK-unused %s + +int f0(int x, + int y, + int z __attribute__((unused))) { + return x; +} + +void f1() { + (void)^(int x, + int y, + int z __attribute__((unused))) { return x; }; +} + +// Used when testing '-Wunused' to see that we only emit one diagnostic, and no +// warnings for the above cases. +static void achor() {}; + +// CHECK: 5:12: warning: unused parameter 'y' +// CHECK: 12:15: warning: unused parameter 'y' +// CHECK-unused: 1 warning generated + +// RUN: %clang_cc1 -fblocks -fsyntax-only -Weverything %s 2>&1 | FileCheck -check-prefix=CHECK-everything %s +// RUN: %clang_cc1 -fblocks -fsyntax-only -Weverything -Werror %s 2>&1 | FileCheck -check-prefix=CHECK-everything-error %s +// RUN: %clang_cc1 -fblocks -fsyntax-only -Weverything -Wno-unused %s 2>&1 | FileCheck -check-prefix=CHECK-everything-no-unused %s +// CHECK-everything: 6 warnings generated +// CHECK-everything-error: 5 errors generated +// CHECK-everything-no-unused: 5 warnings generated + diff --git a/clang/test/Sema/warn-unused-value.c b/clang/test/Sema/warn-unused-value.c new file mode 100644 index 0000000..95cd8fb --- /dev/null +++ b/clang/test/Sema/warn-unused-value.c @@ -0,0 +1,90 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wunused-value -Wunused-label %s +// RUN: %clang_cc1 -fsyntax-only -verify -Wunused %s +// RUN: %clang_cc1 -fsyntax-only -verify -Wall %s + +int i = 0; +int j = 0; + +void foo(); + +// PR4806 +void pr4806() { + 1,foo(); // expected-warning {{expression result unused}} + + // other + foo(); + i; // expected-warning {{expression result unused}} + + i,foo(); // expected-warning {{expression result unused}} + foo(),i; // expected-warning {{expression result unused}} + + i,j,foo(); // expected-warning {{expression result unused}} expected-warning {{expression result unused}} + i,foo(),j; // expected-warning {{expression result unused}} expected-warning {{expression result unused}} + foo(),i,j; // expected-warning {{expression result unused}} expected-warning {{expression result unused}} + + i++; + + i++,foo(); + foo(),i++; + + i++,j,foo(); // expected-warning {{expression result unused}} + i++,foo(),j; // expected-warning {{expression result unused}} + foo(),i++,j; // expected-warning {{expression result unused}} + + i,j++,foo(); // expected-warning {{expression result unused}} + i,foo(),j++; // expected-warning {{expression result unused}} + foo(),i,j++; // expected-warning {{expression result unused}} + + i++,j++,foo(); + i++,foo(),j++; + foo(),i++,j++; + + {}; + ({}); + ({}),foo(); + foo(),({}); + + (int)1U; // expected-warning {{expression result unused}} + (void)1U; + + // pointer to volatile has side effect (thus no warning) + int* pi = &i; + volatile int* pj = &j; + *pi; // expected-warning {{expression result unused}} + *pj; + + foo_label: // expected-warning {{unused label}} + i; // expected-warning {{expression result unused}} +} + +// Don't warn about unused '||', '&&' expressions that contain assignments. +int test_logical_foo1(); +int test_logical_foo2(); +int test_logical_foo3(); +int test_logical_bar() { + int x = 0; + (x = test_logical_foo1()) || // no-warning + (x = test_logical_foo2()) || // no-warning + (x = test_logical_foo3()); // no-warning + + x || test_logical_foo1(); // no-warning + + return x; +} + +// PR8282 +void conditional_for_control_flow(int cond, int x, int y) +{ + cond? y++ : x; // no-warning + cond? y : ++x; // no-warning + cond? (x |= y) : ++x; // no-warning + cond? y : x; // expected-warning {{expression result unused}} +} + +struct s0 { int f0; }; + +void f0(int a); +void f1(struct s0 *a) { + // rdar://8139785 + f0((int)(a->f0 + 1, 10)); // expected-warning {{expression result unused}} +} diff --git a/clang/test/Sema/warn-unused-variables.c b/clang/test/Sema/warn-unused-variables.c new file mode 100644 index 0000000..58e52b1 --- /dev/null +++ b/clang/test/Sema/warn-unused-variables.c @@ -0,0 +1,32 @@ +// RUN: %clang_cc1 -fsyntax-only -Wunused-variable -fblocks -verify %s + +struct s0 { + unsigned int i; +}; + +int proto(int a, int b); + +void f0(void) { + int a __attribute__((unused)), + b; // expected-warning{{unused}} + return; +} + +void f1(void) { + int i; + (void)sizeof(i); + return; +} + +// PR5933 +int f2() { + int X = 4; // Shouldn't have a bogus 'unused variable X' warning. + return Y + X; // expected-error {{use of undeclared identifier 'Y'}} +} + +int f3() { + int X1 = 4; + (void)(Y1 + X1); // expected-error {{use of undeclared identifier 'Y1'}} + (void)(^() { int X = 4; }); // expected-warning{{unused}} + (void)(^() { int X = 4; return Y + X; }); // expected-error {{use of undeclared identifier 'Y'}} +} diff --git a/clang/test/Sema/warn-write-strings.c b/clang/test/Sema/warn-write-strings.c new file mode 100644 index 0000000..dee554c --- /dev/null +++ b/clang/test/Sema/warn-write-strings.c @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -verify -fsyntax-only -fconst-strings %s + +// PR4804 +char* x = "foo"; // expected-warning {{initializing 'char *' with an expression of type 'const char [4]' discards qualifiers}} + +// PR7192 +#include <stddef.h> +void test(wchar_t *dst) { + dst[0] = 0; // Ok. +} diff --git a/clang/test/Sema/wchar.c b/clang/test/Sema/wchar.c new file mode 100644 index 0000000..28ec2f1 --- /dev/null +++ b/clang/test/Sema/wchar.c @@ -0,0 +1,22 @@ +// RUN: %clang %s -fsyntax-only -Xclang -verify +// RUN: %clang %s -fsyntax-only -fshort-wchar -Xclang -verify -DSHORT_WCHAR + +typedef __WCHAR_TYPE__ wchar_t; + +#if defined(_WIN32) || defined(_M_IX86) || defined(__CYGWIN__) \ + || defined(_M_X64) || defined(SHORT_WCHAR) + #define WCHAR_T_TYPE unsigned short +#elif defined(__sun) || defined(__AuroraUX__) + #define WCHAR_T_TYPE long +#else /* Solaris or AuroraUX. */ + #define WCHAR_T_TYPE int +#endif + +int check_wchar_size[sizeof(*L"") == sizeof(wchar_t) ? 1 : -1]; + +void foo() { + WCHAR_T_TYPE t1[] = L"x"; + wchar_t tab[] = L"x"; + WCHAR_T_TYPE t2[] = "x"; // expected-error {{initializer}} + char t3[] = L"x"; // expected-error {{initializer}} +} diff --git a/clang/test/Sema/weak-import-on-enum.c b/clang/test/Sema/weak-import-on-enum.c new file mode 100644 index 0000000..3a2c0e5 --- /dev/null +++ b/clang/test/Sema/weak-import-on-enum.c @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-apple-darwin %s +// RUN: %clang_cc1 -triple i386-apple-darwin9 -fsyntax-only -verify %s +// rdar://10277579 + +enum __attribute__((deprecated)) __attribute__((weak_import)) A { + a0 +}; + diff --git a/clang/test/Sema/x86-attr-force-align-arg-pointer.c b/clang/test/Sema/x86-attr-force-align-arg-pointer.c new file mode 100644 index 0000000..5d36e9a --- /dev/null +++ b/clang/test/Sema/x86-attr-force-align-arg-pointer.c @@ -0,0 +1,21 @@ +// RUN: %clang_cc1 -triple i386-apple-darwin10 -fsyntax-only -verify %s + +int a __attribute__((force_align_arg_pointer)); // expected-warning{{attribute only applies to functions}} + +// It doesn't matter where the attribute is located. +void b(void) __attribute__((force_align_arg_pointer)); +void __attribute__((force_align_arg_pointer)) c(void); + +// Functions only have to be declared force_align_arg_pointer once. +void b(void) {} + +// It doesn't matter which declaration has the attribute. +void d(void); +void __attribute__((force_align_arg_pointer)) d(void) {} + +// Attribute is ignored on function pointer types. +void (__attribute__((force_align_arg_pointer)) *p)(); +typedef void (__attribute__((__force_align_arg_pointer__)) *p2)(); +// Attribute is also ignored on function typedefs. +typedef void __attribute__((force_align_arg_pointer)) e(void); + diff --git a/clang/test/Sema/x86-builtin-palignr.c b/clang/test/Sema/x86-builtin-palignr.c new file mode 100644 index 0000000..6f4b90d --- /dev/null +++ b/clang/test/Sema/x86-builtin-palignr.c @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 -ffreestanding -fsyntax-only -target-feature +ssse3 -target-feature +mmx -verify -triple x86_64-pc-linux-gnu %s +// RUN: %clang_cc1 -ffreestanding -fsyntax-only -target-feature +ssse3 -target-feature +mmx -verify -triple i686-apple-darwin10 %s + +#include <tmmintrin.h> + +__m64 test1(__m64 a, __m64 b, int c) { + // FIXME: The "incompatible result type" error is due to pr10112 and should + // be removed when that is fixed. + return _mm_alignr_pi8(a, b, c); // expected-error {{argument to '__builtin_ia32_palignr' must be a constant integer}} expected-error {{incompatible result type}} +} + +int test2(int N) { + __m128i white2; + white2 = __builtin_ia32_pslldqi128(white2, N); // expected-error {{argument to '__builtin_ia32_pslldqi128' must be a constant integer}} + return 0; +} + |