diff options
Diffstat (limited to 'test/Sema')
188 files changed, 6309 insertions, 0 deletions
diff --git a/test/Sema/128bitint.c b/test/Sema/128bitint.c new file mode 100644 index 0000000..2a18d90 --- /dev/null +++ b/test/Sema/128bitint.c @@ -0,0 +1,6 @@ +// RUN: clang-cc -fsyntax-only -verify %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]; diff --git a/test/Sema/PR2727.c b/test/Sema/PR2727.c new file mode 100644 index 0000000..52d8392 --- /dev/null +++ b/test/Sema/PR2727.c @@ -0,0 +1,8 @@ +// RUN: clang-cc -verify -fsyntax-only -std=c90 %s && +// RUN: clang-cc -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/test/Sema/PR2728.c b/test/Sema/PR2728.c new file mode 100644 index 0000000..26c96fe --- /dev/null +++ b/test/Sema/PR2728.c @@ -0,0 +1,9 @@ +// RUN: clang-cc -verify -fsyntax-only -std=c90 %s && +// RUN: clang-cc -verify -fsyntax-only -std=c99 %s + +struct s +{ + int a; +}; + +int a[__builtin_offsetof(struct s, a) == 0]; diff --git a/test/Sema/PR2919-builtin-types-compat-strips-crv.c b/test/Sema/PR2919-builtin-types-compat-strips-crv.c new file mode 100644 index 0000000..160ec4a --- /dev/null +++ b/test/Sema/PR2919-builtin-types-compat-strips-crv.c @@ -0,0 +1,7 @@ +// RUN: clang-cc -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/test/Sema/PR2923.c b/test/Sema/PR2923.c new file mode 100644 index 0000000..c75e7ba --- /dev/null +++ b/test/Sema/PR2923.c @@ -0,0 +1,12 @@ +// RUN: clang-cc -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/test/Sema/PR2963-enum-constant.c b/test/Sema/PR2963-enum-constant.c new file mode 100644 index 0000000..78f2326 --- /dev/null +++ b/test/Sema/PR2963-enum-constant.c @@ -0,0 +1,17 @@ +// RUN: clang-cc %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 integer constant expression}} +}; diff --git a/test/Sema/address-constant.c b/test/Sema/address-constant.c new file mode 100644 index 0000000..69f2f79 --- /dev/null +++ b/test/Sema/address-constant.c @@ -0,0 +1,10 @@ +// RUN: clang-cc -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/test/Sema/address_spaces.c b/test/Sema/address_spaces.c new file mode 100644 index 0000000..b79799f --- /dev/null +++ b/test/Sema/address_spaces.c @@ -0,0 +1,32 @@ +// RUN: clang-cc %s -fsyntax-only -verify + +#define _AS1 __attribute__((address_space(1))) +#define _AS2 __attribute__((address_space(2))) +#define _AS3 __attribute__((address_space(3))) + +void foo(_AS3 float *a) { + _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}} + + *a = 5.0f; +} + +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 {{illegal implicit cast between two pointers with different address spaces}} \ + expected-warning {{returning 'void __attribute__((address_space(256)))*' discards qualifiers, expected 'void *'}} +} + diff --git a/test/Sema/align-x86.c b/test/Sema/align-x86.c new file mode 100644 index 0000000..2bc1cc8 --- /dev/null +++ b/test/Sema/align-x86.c @@ -0,0 +1,14 @@ +// RUN: clang-cc -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]; + +_Complex double g3; +short chk1[__alignof__(g3) == 8 ? 1 : -1]; +short chk2[__alignof__(_Complex double) == 8 ? 1 : -1]; diff --git a/test/Sema/annotate.c b/test/Sema/annotate.c new file mode 100644 index 0000000..aec2af8 --- /dev/null +++ b/test/Sema/annotate.c @@ -0,0 +1,7 @@ +// RUN: clang-cc %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 requires 1 argument(s)}} +} diff --git a/test/Sema/anonymous-struct-union.c b/test/Sema/anonymous-struct-union.c new file mode 100644 index 0000000..ca1133b --- /dev/null +++ b/test/Sema/anonymous-struct-union.c @@ -0,0 +1,98 @@ +// RUN: clang-cc -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-error{{declaration does not declare anything}} + int int_val; + float float_val; +}; + +static union { // expected-error{{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-error{{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-error{{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-error{{declaration does not declare anything}} + +struct s2 { + union { + int a; + } +}; // expected-error{{expected member name or ';' after declaration specifiers}} diff --git a/test/Sema/arg-duplicate.c b/test/Sema/arg-duplicate.c new file mode 100644 index 0000000..e40a964 --- /dev/null +++ b/test/Sema/arg-duplicate.c @@ -0,0 +1,14 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +int f3(y, x, + x) // expected-error {{redefinition of parameter}} + int y, x, + 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/test/Sema/arg-scope-c99.c b/test/Sema/arg-scope-c99.c new file mode 100644 index 0000000..b5b1c8a --- /dev/null +++ b/test/Sema/arg-scope-c99.c @@ -0,0 +1,2 @@ +// RUN: clang-cc -fsyntax-only -std=c99 -verify %s +int bb(int sz, int ar[sz][sz]) { } diff --git a/test/Sema/arg-scope.c b/test/Sema/arg-scope.c new file mode 100644 index 0000000..c1cc7e1 --- /dev/null +++ b/test/Sema/arg-scope.c @@ -0,0 +1,5 @@ +// RUN: clang-cc -fsyntax-only -verify %s +int aa(int b, int x[sizeof b]) {} + +void foo(int i, int A[i]) {} + diff --git a/test/Sema/array-constraint.c b/test/Sema/array-constraint.c new file mode 100644 index 0000000..5a09e20 --- /dev/null +++ b/test/Sema/array-constraint.c @@ -0,0 +1,52 @@ +// RUN: clang-cc -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 size is negative}} + 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 *); +const char staticAry[] = "test"; +int checkStaticAry() { + strFunc(staticAry); // expected-warning{{passing 'char const [5]' discards qualifiers, expected 'char *'}} +} + + diff --git a/test/Sema/array-declared-as-incorrect-type.c b/test/Sema/array-declared-as-incorrect-type.c new file mode 100644 index 0000000..3f6fa33 --- /dev/null +++ b/test/Sema/array-declared-as-incorrect-type.c @@ -0,0 +1,16 @@ +// RUN: clang-cc -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/test/Sema/array-init.c b/test/Sema/array-init.c new file mode 100644 index 0000000..50148a8 --- /dev/null +++ b/test/Sema/array-init.c @@ -0,0 +1,265 @@ +// RUN: clang-cc -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 'char [4]', expected 'long'}} + +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 'int', expected 'struct threeElements *'}} + + extern int blockScopeExtern[3] = { 1, 3, 5 }; // expected-error{{'extern' variable cannot have an initializer}} + + static long x2[3] = { 1.0, "abc" , 5.8 }; // expected-warning{{incompatible pointer to integer conversion initializing 'char [4]', expected 'long'}} +} + +void test() { + int y1[3] = { + { 1, 2, 3 } // expected-warning{{braces around scalar initializer}} 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 'char [7]', expected 'int'}} + 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 'char [6]', expected 'int'}} + 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 [4]', expected 'char'}} +int t4[sizeof t3 == 6 ? 1 : -1]; +} +struct foo { int z; } w; +int bar (void) { + struct foo z = { w }; //expected-error{{incompatible type initializing 'struct foo', expected 'int'}} + 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-error{{too many braces around scalar initializer}} + +// PR2362 +void varArray() { + int c[][x] = { 0 }; //expected-error{{variable-sized object may not be initialized}} +} + +// PR2151 +int emptyInit() {struct {} x[] = {6};} //expected-warning{{empty struct extension}} expected-error{{initializer for aggregate with no elements}} + +int 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 extension}} expected-warning{{excess elements in struct initializer}} + +struct _Matrix { union { float m[4][4]; }; }; //expected-warning{{anonymous unions are a GNU extension in C}} +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}} diff --git a/test/Sema/asm.c b/test/Sema/asm.c new file mode 100644 index 0000000..0a62545 --- /dev/null +++ b/test/Sema/asm.c @@ -0,0 +1,78 @@ +// RUN: clang-cc %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" : : : "53"); // expected-error {{unknown register name '53' 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 'void const volatile' 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; +} diff --git a/test/Sema/assign-null.c b/test/Sema/assign-null.c new file mode 100644 index 0000000..a343c80 --- /dev/null +++ b/test/Sema/assign-null.c @@ -0,0 +1,10 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +#include <stddef.h> + +typedef void (*hookfunc)(void *arg); +hookfunc hook; + +void clear_hook() { + hook = NULL; +} diff --git a/test/Sema/assign.c b/test/Sema/assign.c new file mode 100644 index 0000000..b25262c --- /dev/null +++ b/test/Sema/assign.c @@ -0,0 +1,15 @@ +// RUN: clang-cc -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/test/Sema/ast-print.c b/test/Sema/ast-print.c new file mode 100644 index 0000000..a8988b0 --- /dev/null +++ b/test/Sema/ast-print.c @@ -0,0 +1,8 @@ +// RUN: clang-cc %s -ast-print + +typedef void func_typedef(); +func_typedef xxx; + +typedef void func_t(int x); +func_t a; + diff --git a/test/Sema/attr-aligned.c b/test/Sema/attr-aligned.c new file mode 100644 index 0000000..6e641cb --- /dev/null +++ b/test/Sema/attr-aligned.c @@ -0,0 +1,21 @@ +// RUN: clang-cc -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 c = 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__(c) == 1? : -1] = { 0 }; +char a3[sizeof(c) == 1? : -1] = { 0 }; diff --git a/test/Sema/attr-cleanup.c b/test/Sema/attr-cleanup.c new file mode 100644 index 0000000..0434981 --- /dev/null +++ b/test/Sema/attr-cleanup.c @@ -0,0 +1,40 @@ +// RUN: clang-cc %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 requires 1 argument(s)}} + int v2 __attribute((cleanup(1, 2))); // expected-error {{attribute requires 1 argument(s)}} + + 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/test/Sema/attr-deprecated.c b/test/Sema/attr-deprecated.c new file mode 100644 index 0000000..6597bad --- /dev/null +++ b/test/Sema/attr-deprecated.c @@ -0,0 +1,45 @@ +// RUN: clang-cc %s -verify -fsyntax-only + +int f() __attribute__((deprecated)); +void g() __attribute__((deprecated)); +void g(); + +void z() __attribute__((bogusattr)); // expected-warning {{'bogusattr' attribute ignored}} + +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}} +} + +typedef struct foo foo_dep __attribute__((deprecated)); +foo_dep *test2; // expected-warning {{'foo_dep' is deprecated}} diff --git a/test/Sema/attr-mode.c b/test/Sema/attr-mode.c new file mode 100644 index 0000000..ac411d7 --- /dev/null +++ b/test/Sema/attr-mode.c @@ -0,0 +1,22 @@ +// RUN: clang-cc -fsyntax-only -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))); diff --git a/test/Sema/attr-nodebug.c b/test/Sema/attr-nodebug.c new file mode 100644 index 0000000..512ecfd --- /dev/null +++ b/test/Sema/attr-nodebug.c @@ -0,0 +1,8 @@ +// RUN: clang-cc %s -verify -fsyntax-only + +int a __attribute__((nodebug)); // expected-warning {{'nodebug' attribute only applies to function types}} + +void t1() __attribute__((nodebug)); + +void t2() __attribute__((nodebug(2))); // expected-error {{attribute requires 0 argument(s)}} + diff --git a/test/Sema/attr-noinline.c b/test/Sema/attr-noinline.c new file mode 100644 index 0000000..cf695f0 --- /dev/null +++ b/test/Sema/attr-noinline.c @@ -0,0 +1,8 @@ +// RUN: clang-cc %s -verify -fsyntax-only + +int a __attribute__((noinline)); // expected-warning {{'noinline' attribute only applies to function types}} + +void t1() __attribute__((noinline)); + +void t2() __attribute__((noinline(2))); // expected-error {{attribute requires 0 argument(s)}} + diff --git a/test/Sema/attr-noreturn.c b/test/Sema/attr-noreturn.c new file mode 100644 index 0000000..d1417f0 --- /dev/null +++ b/test/Sema/attr-noreturn.c @@ -0,0 +1,27 @@ +// RUN: clang-cc -verify -fsyntax-only %s + +static void (*fp0)(void) __attribute__((noreturn)); + +static void __attribute__((noreturn)) f0(void) { + fatal(); +} + +// On K&R +int f1() __attribute__((noreturn)); + +int g0 __attribute__((noreturn)); // expected-warning {{'noreturn' attribute only applies to function types}} + +int f2() __attribute__((noreturn(1, 2))); // expected-error {{attribute requires 0 argument(s)}} + +void f3() __attribute__((noreturn)); +void f3() { + return; // expected-error {{function 'f3' declared 'noreturn' should not return}} +} + +#pragma clang diagnostic warning "-Winvalid-noreturn" + +void f4() __attribute__((noreturn)); +void f4() { + return; // expected-warning {{function 'f4' declared 'noreturn' should not return}} +} + diff --git a/test/Sema/attr-regparm.c b/test/Sema/attr-regparm.c new file mode 100644 index 0000000..944f014 --- /dev/null +++ b/test/Sema/attr-regparm.c @@ -0,0 +1,7 @@ +// RUN: clang-cc -triple i386-apple-darwin9 -fsyntax-only -verify %s + +__attribute((regparm(2))) int x(void); +__attribute((regparm(1.0))) int x(void); // expected-error{{'regparm' attribute requires integer constant}} +__attribute((regparm(-1))) int x(void); // expected-error{{'regparm' parameter must be between 0 and 3 inclusive}} +__attribute((regparm(5))) int x(void); // expected-error{{'regparm' parameter must be between 0 and 3 inclusive}} +__attribute((regparm(5,3))) int x(void); // expected-error{{attribute requires 1 argument(s)}} diff --git a/test/Sema/attr-unused.c b/test/Sema/attr-unused.c new file mode 100644 index 0000000..dbb5e63 --- /dev/null +++ b/test/Sema/attr-unused.c @@ -0,0 +1,12 @@ +// RUN: clang-cc -verify -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 requires 0 argument(s)}} diff --git a/test/Sema/attr-used.c b/test/Sema/attr-used.c new file mode 100644 index 0000000..fdabf7f --- /dev/null +++ b/test/Sema/attr-used.c @@ -0,0 +1,20 @@ +// RUN: clang-cc -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 variable and function types}} + 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/test/Sema/attr-warn_unused_result.c b/test/Sema/attr-warn_unused_result.c new file mode 100644 index 0000000..b4ef1bb --- /dev/null +++ b/test/Sema/attr-warn_unused_result.c @@ -0,0 +1,19 @@ +// RUN: clang-cc %s -fsyntax-only -verify +// rdar://6587766 + +int fn1() __attribute__ ((warn_unused_result)); +int fn2() __attribute__ ((pure)); +int fn3() __attribute__ ((const)); + +int foo() { + if (fn1() < 0 || fn2(2,1) < 0 || fn3(2) < 0) // no warnings + return -1; + + fn1(); // expected-warning {{expression result unused}} + fn2(92, 21); // expected-warning {{expression result unused}} + fn3(42); // expected-warning {{expression result unused}} + return 0; +} + +int bar __attribute__ ((warn_unused_result)); // expected-warning {{warning: 'warn_unused_result' attribute only applies to function types}} + diff --git a/test/Sema/attr-weak.c b/test/Sema/attr-weak.c new file mode 100644 index 0000000..b79e1e7 --- /dev/null +++ b/test/Sema/attr-weak.c @@ -0,0 +1,13 @@ +// RUN: clang-cc -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); +int __attribute__((weak_import)) g5(void) { +} + +struct __attribute__((weak)) s0 {}; // expected-warning {{'weak' attribute only applies to variable and function types}} +struct __attribute__((weak_import)) s1 {}; // expected-warning {{'weak_import' attribute only applies to variable and function types}} + diff --git a/test/Sema/bitfield-layout.c b/test/Sema/bitfield-layout.c new file mode 100644 index 0000000..4405c80 --- /dev/null +++ b/test/Sema/bitfield-layout.c @@ -0,0 +1,32 @@ +// RUN: clang-cc %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) diff --git a/test/Sema/bitfield.c b/test/Sema/bitfield.c new file mode 100644 index 0000000..655f741 --- /dev/null +++ b/test/Sema/bitfield.c @@ -0,0 +1,36 @@ +// RUN: clang-cc %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' 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 bitfield 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__(x.x<<1) y; +int y; diff --git a/test/Sema/block-args.c b/test/Sema/block-args.c new file mode 100644 index 0000000..a2d8e5a --- /dev/null +++ b/test/Sema/block-args.c @@ -0,0 +1,29 @@ +// RUN: clang-cc %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, 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); // C style (...), ok. + ^(int x, ...){return 5;}(arg, arg); // Explicit varargs, ok. +} + +int main(int argc) { + ^(int argCount) { + argCount = 3; + }(argc); +} diff --git a/test/Sema/block-as-object.m b/test/Sema/block-as-object.m new file mode 100644 index 0000000..219b1a0 --- /dev/null +++ b/test/Sema/block-as-object.m @@ -0,0 +1,20 @@ +// RUN: clang-cc %s -fsyntax-only -verify -fblocks + +@interface Whatever +- copy; +@end + +typedef long (^MyBlock)(id obj1, id obj2); + +void foo(MyBlock b) { + id bar = [b copy]; +} + +void foo2(id b) { +} + +void foo3(void (^block)(void)) { + foo2(block); + id x; + foo(x); +} diff --git a/test/Sema/block-byref-args.c b/test/Sema/block-byref-args.c new file mode 100644 index 0000000..39745d5 --- /dev/null +++ b/test/Sema/block-byref-args.c @@ -0,0 +1,18 @@ +// RUN: clang-cc %s -fsyntax-only -verify -fblocks + +#include <stdio.h> + +int main(int argc, char **argv) { + __block void(*bobTheFunction)(void); + __block void(^bobTheBlock)(void); + + bobTheBlock = ^{;}; + + __block int JJJJ; + __attribute__((__blocks__(byref))) int III; + + int (^XXX)(void) = ^{ return III+JJJJ; }; + + return 0; +} + diff --git a/test/Sema/block-call.c b/test/Sema/block-call.c new file mode 100644 index 0000000..9d3ff71 --- /dev/null +++ b/test/Sema/block-call.c @@ -0,0 +1,55 @@ +// RUN: clang-cc -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; // expected-error {{incompatible block pointer types initializing 'int (^)()', expected 'int (^)(int)'}} + PFR = II; // OK + + int (^IFP) () = PFR; + + + const int (^CIC) () = IFP; // expected-error {{incompatible block pointer types initializing 'int (^)()', expected 'int const (^)()'}} + + + const int (^CICC) () = CIC; + + int * const (^IPCC) () = 0; + + int * const (^IPCC1) () = IPCC; + + int * (^IPCC2) () = IPCC; // expected-error {{incompatible block pointer types initializing 'int *const (^)()', expected 'int *(^)()'}} + + 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 (^)(double))', expected 'int (^)(int, char (^)(float))'}} + + IPCC2 = 0; + IPCC2 = 1; // expected-error {{invalid conversion assigning integer 'int', expected block pointer 'int *(^)()'}} + int (^x)() = 0; + int (^y)() = 3; // expected-error {{invalid conversion initializing integer 'int', expected block pointer 'int (^)()'}} + int a = 1; + int (^z)() = a+4; // expected-error {{invalid conversion initializing integer 'int', expected block pointer '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/test/Sema/block-explicit-return-type.c b/test/Sema/block-explicit-return-type.c new file mode 100644 index 0000000..c7b26b3 --- /dev/null +++ b/test/Sema/block-explicit-return-type.c @@ -0,0 +1,81 @@ +// RUN: clang-cc -ObjC -fsyntax-only %s -verify -fblocks +// FIXME: should compile +// Test for blocks with explicit return type specified. + +typedef float * PF; +float gf; + +@interface NSView + - (id) some_method_that_returns_id; +@end + +NSView *some_object; + +void some_func (NSView * (^) (id)); + +typedef struct dispatch_item_s *dispatch_item_t; +typedef void (^completion_block_t)(void); + +typedef double (^myblock)(int); +double test(myblock I); + +int main() +{ + __block int x = 1; + __block int y = 2; + + (void)^void *{ return 0; }; + + (void)^float(float y){ return y; }; + + (void)^double (float y, double d) + { + if (y) + return d; + else + return y; + }; + + const char * (^chb) (int flag, const char *arg, char *arg1) = ^ const char * (int flag, const char *arg, char *arg1) { + if (flag) + return 0; + if (flag == 1) + return arg; + else if (flag == 2) + return ""; + return arg1; + }; + + (void)^PF { return &gf; }; + + some_func(^ NSView * (id whatever) { return [some_object some_method_that_returns_id]; }); + + double res = test(^(int z){x = y+z; return (double)z; }); +} + +void func() +{ + completion_block_t X; + + completion_block_t (^blockx)(dispatch_item_t) = ^completion_block_t (dispatch_item_t item) { + return X; + }; + + completion_block_t (^blocky)(dispatch_item_t) = ^(dispatch_item_t item) { + return X; + }; + + blockx = blocky; + +} + + +// intent: block taking int returning block that takes char,int and returns int +int (^(^block)(double x))(char, short); + +void foo() { + int one = 1; + block = ^(double x){ return ^(char c, short y) { return one + c + y; };}; // expected-error {{returning block that lives on the local stack}} + // or: + block = ^(double x){ return ^(char c, short y) { return one + (int)c + y; };}; // expected-error {{returning block that lives on the local stack}} +} diff --git a/test/Sema/block-labels.c b/test/Sema/block-labels.c new file mode 100644 index 0000000..f0f8c48 --- /dev/null +++ b/test/Sema/block-labels.c @@ -0,0 +1,17 @@ +// RUN: clang-cc %s -verify -fblocks -fsyntax-only + +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; return ^{ A:return 1;}(); // expected-error {{use of undeclared label 'A'}} +} diff --git a/test/Sema/block-literal.c b/test/Sema/block-literal.c new file mode 100644 index 0000000..19d476f --- /dev/null +++ b/test/Sema/block-literal.c @@ -0,0 +1,124 @@ +// RUN: clang-cc -fsyntax-only %s -verify -fblocks + +void I( void (^)(void)); +void (^noop)(void); + +void nothing(); +int printf(const char*, ...); + +typedef void (^T) (void); + +void takeclosure(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; + + takeclosure(^{ printf("%d\n", x); }); + + while (1) { + takeclosure(^{ + 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 {{goto not allowed}} + }); + break; + } + +foo: + takeclosure(^{ x = 4; }); // expected-error {{variable is not assignable (missing __block type specifier)}} + __block y = 7; // expected-warning {{type specifier missing, defaults to 'int'}} + takeclosure(^{ 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) { }; + +#if 0 +// Old syntax. FIXME: convert/test. +void test_byref() { + int i; + + X = ^{| g |}; // error {{use of undeclared identifier 'g'}} + + X = ^{| i,i,i | }; + + X = ^{|i| i = 0; }; + +} + +// TODO: global closures someday. +void *A = ^{}; +void *B = ^(int){ A = 0; }; + + +// Closures can not take return types at this point. +void test_retvals() { + // Explicit return value. + ^int{}; // error {{closure with explicit return type requires argument list}} + X = ^void(){}; + + // Optional specification of return type. + X = ^char{ return 'x'; }; // error {{closure with explicit return type requires argument list}} + + X = ^/*missing declspec*/ *() { return (void*)0; }; + X = ^void*() { return (void*)0; }; + + //X = ^char(short c){ if (c) return c; else return (int)4; }; + +} + +#endif diff --git a/test/Sema/block-misc.c b/test/Sema/block-misc.c new file mode 100644 index 0000000..93ca3c4 --- /dev/null +++ b/test/Sema/block-misc.c @@ -0,0 +1,187 @@ +// RUN: clang-cc -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) // expected-error {{comparison of distinct block types}} + donotwarn(); + + if (PFR == (int (^) (int))IFP) // OK + donotwarn(); + + if (PFR == 0) // OK + donotwarn(); + + if (PFR) // OK + donotwarn(); + + if (!PFR) // OK + donotwarn(); + + return PFR != IFP; // expected-error {{comparison of distinct block types}} +} + +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}} + +int 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; +} + + +// 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: + // FIXME: This should say "jump out of block not legal" when gotos are allowed. + ^{ goto somelabel; }(); // expected-error {{goto not allowed in block literal}} +} + +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)()) { +} + +void (^test15f)(void); +void test15() { + foo(^{ return LESS; }); // expected-error {{incompatible block pointer types passing 'int (^)(void)', expected '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 test17() { + void (^bp)(int); + void (*rp)(int); + void (^bp1)(); + void *vp = bp; + + f(1 ? bp : vp); + f(1 ? vp : bp); + f(1 ? bp : bp1); // expected-error {{incompatible operand types ('void (^)(int)' and 'void (^)()')}} + (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}} +} diff --git a/test/Sema/block-printf-attribute-1.c b/test/Sema/block-printf-attribute-1.c new file mode 100644 index 0000000..ce30b8e --- /dev/null +++ b/test/Sema/block-printf-attribute-1.c @@ -0,0 +1,15 @@ +// RUN: clang-cc %s -fsyntax-only -verify -fblocks + +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, ...) {}; + + // FIXME: argument type poking not yet supportted. + z(1, "%s", 1); /* { dg-warning "format \\'\%s\\' expects type \\'char \\*\\'\, but argument 3 has type \\'int\\'" } */ + z(1, "%s", "HELLO"); // OK + +} + diff --git a/test/Sema/block-return.c b/test/Sema/block-return.c new file mode 100644 index 0000000..e1a3cfd --- /dev/null +++ b/test/Sema/block-return.c @@ -0,0 +1,104 @@ +// RUN: clang-cc -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 'int (^)(void)', expected 'short (^)(void)'}} + + CL X = ^{ + if (2) + return; + return 1; // expected-error {{void block should not return a value}} + }; + + int (^Y) (void) = ^{ + if (3) + return 1; + else + return; // expected-error {{non-void block should return a value}} + }; + + char *(^Z)(void) = ^{ + if (3) + return ""; + else + return (char*)0; + }; + + double (^A)(void) = ^ { // expected-error {{incompatible block pointer types initializing 'float (^)(void)', expected 'double (^)(void)'}} + if (1) + return (float)1.0; + else + if (2) + return (double)2.0; + return 1; + }; + char *(^B)(void) = ^{ + if (3) + return ""; + else + return 2; // expected-warning {{incompatible integer to pointer conversion returning 'int', expected 'char *'}} + }; + + return ^{ return 1; }; // expected-error {{incompatible block pointer types returning 'int (^)(void)', expected 'CL'}} +} + +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 foo4() { + int (^xx)(const char *s) = ^(char *s) { return 1; }; // expected-error {{incompatible block pointer types initializing 'int (^)(char *)', expected 'int (^)(char const *)'}} + int (*yy)(const char *s) = funk; // expected-warning {{incompatible pointer types initializing 'int (char *)', expected 'int (*)(char const *)'}} + + int (^nested)(char *s) = ^(char *str) { void (^nest)(void) = ^(void) { printf("%s\n", str); }; next(); return 1; }; // expected-warning{{implicitly declaring C library function 'printf' with type 'int (char const *, ...)'}} \ + // 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}} +} + +int (*funcptr3[5])(long); +int sz8 = sizeof(^int (*[5])(long) {return funcptr3;}); // expected-error {{block declared as returning an array}} + +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}} +} diff --git a/test/Sema/block-sentinel-attribute.c b/test/Sema/block-sentinel-attribute.c new file mode 100644 index 0000000..a7d4df1 --- /dev/null +++ b/test/Sema/block-sentinel-attribute.c @@ -0,0 +1,25 @@ +// RUN: clang-cc -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}} + 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/test/Sema/block-storageclass.c b/test/Sema/block-storageclass.c new file mode 100644 index 0000000..3d2527b --- /dev/null +++ b/test/Sema/block-storageclass.c @@ -0,0 +1,18 @@ +// RUN: clang-cc %s -fsyntax-only -verify -fblocks + +#include <stdio.h> +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/test/Sema/builtin-object-size.c b/test/Sema/builtin-object-size.c new file mode 100644 index 0000000..4b15cb1 --- /dev/null +++ b/test/Sema/builtin-object-size.c @@ -0,0 +1,28 @@ +// RUN: clang-cc -fsyntax-only -verify %s && +// RUN: clang-cc -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/test/Sema/builtin-prefetch.c b/test/Sema/builtin-prefetch.c new file mode 100644 index 0000000..6b39e75 --- /dev/null +++ b/test/Sema/builtin-prefetch.c @@ -0,0 +1,13 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +int 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, 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/test/Sema/builtin-stackaddress.c b/test/Sema/builtin-stackaddress.c new file mode 100644 index 0000000..67582a5 --- /dev/null +++ b/test/Sema/builtin-stackaddress.c @@ -0,0 +1,16 @@ +// RUN: clang-cc -fsyntax-only -verify %s +void* a(unsigned x) { +return __builtin_return_address(0); +} + +void b(unsigned x) { +return __builtin_return_address(x); // expected-error{{the level argument for a stack address builtin must be constant}} +} + +void* c(unsigned x) { +return __builtin_frame_address(0); +} + +void d(unsigned x) { +return __builtin_frame_address(x); // expected-error{{the level argument for a stack address builtin must be constant}} +} diff --git a/test/Sema/builtins.c b/test/Sema/builtins.c new file mode 100644 index 0000000..e57aec5 --- /dev/null +++ b/test/Sema/builtins.c @@ -0,0 +1,52 @@ +// RUN: clang-cc %s -fsyntax-only -verify -pedantic -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() { + CFSTR("\242"); + CFSTR("\0"); // expected-warning {{ CFString literal contains NUL character }} + CFSTR(242); // expected-error {{ CFString literal is not a string constant }} expected-warning {{incompatible integer to pointer conversion}} + CFSTR("foo", "bar"); // expected-error {{too many arguments to function call}} +} + + +typedef __attribute__(( ext_vector_type(16) )) unsigned char uchar16; + +// rdar://5905347 +unsigned char test8( short v ) { + uchar16 c; + return __builtin_ia32_vec_ext_v4si( c ); // expected-error {{too few arguments to function}} +} + + +// atomics. + +unsigned char 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((int**)0, 42i); // expected-warning {{imaginary constants are an extension}} +} diff --git a/test/Sema/c89-2.c b/test/Sema/c89-2.c new file mode 100644 index 0000000..723bd7c --- /dev/null +++ b/test/Sema/c89-2.c @@ -0,0 +1,7 @@ +/* RUN: not clang-cc %s -std=c89 -pedantic-errors + */ + +/* We can't put expected-warning lines on #if lines. */ + +#if 1LL /* expected-warning {{long long}} */ +#endif diff --git a/test/Sema/c89.c b/test/Sema/c89.c new file mode 100644 index 0000000..e7585c3 --- /dev/null +++ b/test/Sema/c89.c @@ -0,0 +1,82 @@ +/* RUN: clang-cc %s -std=c89 -pedantic -fsyntax-only -verify + */ +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() {} + +/* 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 {{use of C99-specific array features}} */ +void test11 (int x[static 4]); /* expected-warning {{use of C99-specific array features}} */ + +void test12 (int x[const 4]) { /* expected-warning {{use of C99-specific array features}} */ + int Y[x[1]]; /* expected-warning {{variable length arrays are a C99 feature, accepted as an extension}} */ +} + +/* 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)(); } diff --git a/test/Sema/callingconv.c b/test/Sema/callingconv.c new file mode 100644 index 0000000..cb69c59 --- /dev/null +++ b/test/Sema/callingconv.c @@ -0,0 +1,10 @@ +// RUN: clang-cc %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 requires 0 argument(s)}} +} diff --git a/test/Sema/carbon-pth.c b/test/Sema/carbon-pth.c new file mode 100644 index 0000000..c956d2a --- /dev/null +++ b/test/Sema/carbon-pth.c @@ -0,0 +1,7 @@ +// RUN: clang-cc -mcpu=pentium4 -emit-pth -o %t %s && +// RUN: clang-cc -mcpu=pentium4 -token-cache %t %s && +// RUN: clang-cc -mcpu=pentium4 -token-cache %t %s -E %s -o /dev/null +#ifdef __APPLE__ +#include <Carbon/Carbon.h> +#endif + diff --git a/test/Sema/carbon.c b/test/Sema/carbon.c new file mode 100644 index 0000000..5eda438 --- /dev/null +++ b/test/Sema/carbon.c @@ -0,0 +1,5 @@ +// RUN: clang-cc -mcpu=pentium4 %s -print-stats +#ifdef __APPLE__ +#include <Carbon/Carbon.h> +#endif + diff --git a/test/Sema/cast-to-union.c b/test/Sema/cast-to-union.c new file mode 100644 index 0000000..24f913b --- /dev/null +++ b/test/Sema/cast-to-union.c @@ -0,0 +1,19 @@ +// RUN: clang-cc -fsyntax-only -verify -pedantic %s + +union u { int i; }; +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}} +} + +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{{incompatible type initializing 'int', expected 'union u'}} +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/test/Sema/cast.c b/test/Sema/cast.c new file mode 100644 index 0000000..ec19626 --- /dev/null +++ b/test/Sema/cast.c @@ -0,0 +1,14 @@ +// RUN: clang-cc -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}} +} + diff --git a/test/Sema/check-increment.c b/test/Sema/check-increment.c new file mode 100644 index 0000000..9809544 --- /dev/null +++ b/test/Sema/check-increment.c @@ -0,0 +1,10 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +#include <stdio.h> +typedef int *pint; +int main() { + int a[5] = {0}; + pint p = a; + p++; + printf("%d\n", *p); +} diff --git a/test/Sema/compare.c b/test/Sema/compare.c new file mode 100644 index 0000000..4b44bf5 --- /dev/null +++ b/test/Sema/compare.c @@ -0,0 +1,17 @@ +// RUN: clang-cc -fsyntax-only -pedantic -verify %s + +int test(char *C) { // nothing here should warn. + return C != ((void*)0); + return C != (void*)0; + return C != 0; +} + +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}} +} diff --git a/test/Sema/complex-int.c b/test/Sema/complex-int.c new file mode 100644 index 0000000..5977b4d --- /dev/null +++ b/test/Sema/complex-int.c @@ -0,0 +1,52 @@ +// RUN: clang-cc %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; +} + diff --git a/test/Sema/complex-promotion.c b/test/Sema/complex-promotion.c new file mode 100644 index 0000000..3d86c20 --- /dev/null +++ b/test/Sema/complex-promotion.c @@ -0,0 +1,15 @@ +// RUN: clang-cc %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/test/Sema/compound-literal.c b/test/Sema/compound-literal.c new file mode 100644 index 0000000..b51bcfe2 --- /dev/null +++ b/test/Sema/compound-literal.c @@ -0,0 +1,33 @@ +// RUN: clang-cc -fsyntax-only -verify -pedantic %s + +struct foo { int a, b; }; + +static struct foo t = (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 'char [2]', expected 'long'}} + +typedef struct { } cache_t; // -expected-warning{{use of empty struct 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)'}} +} diff --git a/test/Sema/conditional-expr.c b/test/Sema/conditional-expr.c new file mode 100644 index 0000000..1f0a9de --- /dev/null +++ b/test/Sema/conditional-expr.c @@ -0,0 +1,51 @@ +// RUN: clang-cc -fsyntax-only -verify -pedantic %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 'double *', expected 'int *'}} + dp = ip; // expected-warning {{incompatible pointer types assigning 'int *', expected 'double *'}} + dp = 0 ? (double *)0 : (void *)0; + vp = 0 ? (double *)0 : (void *)0; + ip = 0 ? (double *)0 : (void *)0; // expected-warning {{incompatible pointer types assigning 'double *', expected 'int *'}} + + 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; +} + +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 *', expected 'int'}} +} diff --git a/test/Sema/conditional.c b/test/Sema/conditional.c new file mode 100644 index 0000000..1c7486a --- /dev/null +++ b/test/Sema/conditional.c @@ -0,0 +1,15 @@ +// RUN: clang-cc %s -fsyntax-only -verify + +const char* test1 = 1 ? "i" : 1 == 1 ? "v" : "r"; + +void _efree(void *ptr); + +int _php_stream_free1() +{ + return (1 ? free(0) : _efree(0)); // expected-error {{incompatible type returning 'void', expected 'int'}} +} + +int _php_stream_free2() +{ + return (1 ? _efree(0) : free(0)); // expected-error {{incompatible type returning 'void', expected 'int'}} +} diff --git a/test/Sema/const-eval.c b/test/Sema/const-eval.c new file mode 100644 index 0000000..79f96b9 --- /dev/null +++ b/test/Sema/const-eval.c @@ -0,0 +1,67 @@ +// RUN: clang-cc -fsyntax-only -verify %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)) // FIXME: This should give an error +EVAL_EXPR(12, 1.0&&2.0) +EVAL_EXPR(13, x || 3.0) + +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); // expected-error {{fields must have a constant size}} +} + +// 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 {{array size is negative}} +}; + +EVAL_EXPR(19, ((int)&*(char*)10 == 10 ? 1 : -1)); + +EVAL_EXPR(20, __builtin_constant_p(*((int*) 10), -1, 1)); + +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) diff --git a/test/Sema/const-ptr-int-ptr-cast.c b/test/Sema/const-ptr-int-ptr-cast.c new file mode 100644 index 0000000..4e08bff --- /dev/null +++ b/test/Sema/const-ptr-int-ptr-cast.c @@ -0,0 +1,5 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +#include <stdint.h> + +char *a = (void*)(uintptr_t)(void*)&a; diff --git a/test/Sema/constant-builtins-2.c b/test/Sema/constant-builtins-2.c new file mode 100644 index 0000000..146d9e9 --- /dev/null +++ b/test/Sema/constant-builtins-2.c @@ -0,0 +1,50 @@ +// RUN: clang-cc -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); diff --git a/test/Sema/constant-builtins.c b/test/Sema/constant-builtins.c new file mode 100644 index 0000000..f8cea33 --- /dev/null +++ b/test/Sema/constant-builtins.c @@ -0,0 +1,24 @@ +// RUN: clang-cc -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/test/Sema/constructor-attribute.c b/test/Sema/constructor-attribute.c new file mode 100644 index 0000000..bf876f3 --- /dev/null +++ b/test/Sema/constructor-attribute.c @@ -0,0 +1,15 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +int x __attribute__((constructor)); // expected-warning {{'constructor' attribute only applies to function types}} +int f() __attribute__((constructor)); +int f() __attribute__((constructor(1))); +int f() __attribute__((constructor(1,2))); // expected-error {{attribute requires 0 or 1 argument(s)}} +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 function types}} +int f() __attribute__((destructor)); +int f() __attribute__((destructor(1))); +int f() __attribute__((destructor(1,2))); // expected-error {{attribute requires 0 or 1 argument(s)}} +int f() __attribute__((destructor(1.0))); // expected-error {{'destructor' attribute requires parameter 1 to be an integer constant}} + + diff --git a/test/Sema/darwin-align-cast.c b/test/Sema/darwin-align-cast.c new file mode 100644 index 0000000..09808b5 --- /dev/null +++ b/test/Sema/darwin-align-cast.c @@ -0,0 +1,23 @@ +// RUN: clang-cc -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; +} + diff --git a/test/Sema/decl-invalid.c b/test/Sema/decl-invalid.c new file mode 100644 index 0000000..051f0f7 --- /dev/null +++ b/test/Sema/decl-invalid.c @@ -0,0 +1,29 @@ +// RUN: clang-cc %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-error {{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 '('}} \ + expected-error{{expected ';' at end of declaration}} +} + +int; // expected-error {{declaration does not declare anything}} +typedef int; // expected-error {{declaration does not declare anything}} +const int; // expected-error {{declaration does not declare anything}} +struct; // expected-error {{declaration of anonymous struct must be a definition}} // expected-error {{declaration does not declare anything}} +typedef int I; +I; // expected-error {{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/test/Sema/decl-type-merging.c b/test/Sema/decl-type-merging.c new file mode 100644 index 0000000..1b789a1 --- /dev/null +++ b/test/Sema/decl-type-merging.c @@ -0,0 +1,16 @@ +// RUN: clang-cc -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]); +int 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/test/Sema/declspec.c b/test/Sema/declspec.c new file mode 100644 index 0000000..e325cc8 --- /dev/null +++ b/test/Sema/declspec.c @@ -0,0 +1,23 @@ +// RUN: clang-cc %s -verify -fsyntax-only +typedef char T[4]; + +T foo(int n, int m) { } // expected-error {{cannot return array or function}} + +void foof(const char *, ...) __attribute__((__format__(__printf__, 1, 2))), barf (void); + +int typedef validTypeDecl() { } // expected-error {{function definition declared 'typedef'}} + +struct _zend_module_entry { } +typedef struct _zend_function_entry { } // expected-error {{cannot combine with previous 'struct' declaration specifier}} +static void buggy(int *x) { } // expected-error {{function definition declared 'typedef'}} \ + // expected-error {{cannot combine with previous 'typedef' declaration specifier}} \ + // expected-error {{cannot combine with previous 'struct' declaration specifier}} + +// 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}} + diff --git a/test/Sema/default.c b/test/Sema/default.c new file mode 100644 index 0000000..5dac991 --- /dev/null +++ b/test/Sema/default.c @@ -0,0 +1,8 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +void f5 (int z) { + if (z) + default: // expected-error {{not in switch statement}} + ; // expected-warning {{if statement has empty body}} +} + diff --git a/test/Sema/default1.c b/test/Sema/default1.c new file mode 100644 index 0000000..6e8a27b --- /dev/null +++ b/test/Sema/default1.c @@ -0,0 +1,2 @@ +// RUN: clang-cc -fsyntax-only -verify %s +void f(int i = 0); // expected-error {{C does not support default arguments}} diff --git a/test/Sema/deref.c b/test/Sema/deref.c new file mode 100644 index 0000000..965940e --- /dev/null +++ b/test/Sema/deref.c @@ -0,0 +1,44 @@ +/* RUN: clang-cc -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/test/Sema/designated-initializers.c b/test/Sema/designated-initializers.c new file mode 100644 index 0000000..ae951d4 --- /dev/null +++ b/test/Sema/designated-initializers.c @@ -0,0 +1,234 @@ +// RUN: clang-cc -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 +}; + + diff --git a/test/Sema/dllimport-dllexport.c b/test/Sema/dllimport-dllexport.c new file mode 100644 index 0000000..90ed145 --- /dev/null +++ b/test/Sema/dllimport-dllexport.c @@ -0,0 +1,18 @@ +// RUN: clang-cc -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 variable and function types}} + +typedef int __attribute__((dllimport)) type7; // expected-warning{{'dllimport' attribute only applies to variable and function}} + +void __attribute__((dllimport)) foo6(); +void foo6(){} // expected-warning {{'foo6' redeclared without dllimport attribute: previous dllimport ignored}} diff --git a/test/Sema/enum.c b/test/Sema/enum.c new file mode 100644 index 0000000..adb9375 --- /dev/null +++ b/test/Sema/enum.c @@ -0,0 +1,86 @@ +// RUN: clang-cc %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'}} +}; + +// 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) + ; + (void)ve2; + ve2; // expected-warning {{expression result unused}} +} + +// PR2416 +enum someenum {}; // expected-warning {{use of empty enum extension}} + +// <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(); +} diff --git a/test/Sema/expr-address-of.c b/test/Sema/expr-address-of.c new file mode 100644 index 0000000..909acfb --- /dev/null +++ b/test/Sema/expr-address-of.c @@ -0,0 +1,109 @@ +// RUN: clang-cc %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); +} diff --git a/test/Sema/expr-comma-c89.c b/test/Sema/expr-comma-c89.c new file mode 100644 index 0000000..b2b17dc --- /dev/null +++ b/test/Sema/expr-comma-c89.c @@ -0,0 +1,18 @@ +// RUN: clang-cc %s -fsyntax-only -verify -std=c99 +// rdar://6095180 + +#include <assert.h> +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/test/Sema/expr-comma.c b/test/Sema/expr-comma.c new file mode 100644 index 0000000..6407986 --- /dev/null +++ b/test/Sema/expr-comma.c @@ -0,0 +1,18 @@ +// RUN: clang-cc %s -fsyntax-only -verify -std=c89 +// rdar://6095180 + +#include <assert.h> +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/test/Sema/exprs.c b/test/Sema/exprs.c new file mode 100644 index 0000000..3fd1437 --- /dev/null +++ b/test/Sema/exprs.c @@ -0,0 +1,108 @@ +// RUN: clang-cc %s -verify -pedantic -fsyntax-only -fblocks=0 + +// 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 bitfield}} + R = __alignof(P->y); // ok. + R = sizeof(P->x); // expected-error {{invalid application of 'sizeof' to bitfield}} + 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}} +} + +// rdar://6719156 +void test13( + void (^P)()) { // expected-error {{blocks support disabled - compile with -fblocks}} + P(); + P = ^(){}; // expected-error {{blocks support disabled - compile with -fblocks}} +} + + +// rdar://6326239 - Vector comparisons are not fully trusted yet, until the +// backend is known to work, just unconditionally reject them. +void test14() { + typedef long long __m64 __attribute__((__vector_size__(8))); + typedef short __v4hi __attribute__((__vector_size__(8))); + + __v4hi a; + __m64 mask = (__m64)((__v4hi)a > // expected-error {{comparison of vector types ('__v4hi' and '__v4hi') not supported yet}} + (__v4hi)a); +} + diff --git a/test/Sema/ext_vector_components.c b/test/Sema/ext_vector_components.c new file mode 100644 index 0000000..422a9e6 --- /dev/null +++ b/test/Sema/ext_vector_components.c @@ -0,0 +1,37 @@ +// RUN: clang-cc -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; + +static void test() { + float2 vec2, vec2_2; + float3 vec3; + float4 vec4, vec4_2, *vec4p; + 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 + + vec3 = vec4.xyz; // legal, shorten + f = vec2.x; // legal, shorten + f = vec4.xy.x; // legal, shorten + + vec2 = vec3.hi; // expected-error {{vector component access invalid for odd-sized type 'float3'}} + + 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'}} + + vec4p->yz = vec4p->xy; +} diff --git a/test/Sema/flexible-array-init.c b/test/Sema/flexible-array-init.c new file mode 100644 index 0000000..afe31fb --- /dev/null +++ b/test/Sema/flexible-array-init.c @@ -0,0 +1,58 @@ +// RUN: clang-cc -fsyntax-only -pedantic -verify %s +struct one { + int a; + int values[]; // expected-note 3{{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-warning{{flexible array initialization is a GNU extension}} +} + +struct foo { + int x; + int y[]; // expected-note 6 {{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{{non-empty initialization of flexible array member inside subobject}} +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{{non-empty initialization of flexible array member inside subobject}} + +struct foo desig_foo = { .y = {2, 3, 4} }; +struct bar desig_bar = { .z.y = { } }; // expected-warning{{use of GNU empty initializer extension}} \ + // expected-warning{{zero size arrays are an extension}} +struct bar desig_bar2 = { .z.y = { 2, 3, 4} }; // expected-error{{non-empty initialization of flexible array member inside subobject}} +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}} +}; diff --git a/test/Sema/floating-point-compare.c b/test/Sema/floating-point-compare.c new file mode 100644 index 0000000..763a8f4 --- /dev/null +++ b/test/Sema/floating-point-compare.c @@ -0,0 +1,25 @@ +// RUN: clang-cc -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/test/Sema/for.c b/test/Sema/for.c new file mode 100644 index 0000000..183a95d --- /dev/null +++ b/test/Sema/for.c @@ -0,0 +1,7 @@ +// RUN: clang-cc -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/test/Sema/format-attribute.c b/test/Sema/format-attribute.c new file mode 100644 index 0000000..cb82331 --- /dev/null +++ b/test/Sema/format-attribute.c @@ -0,0 +1,34 @@ +//RUN: clang-cc -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); +} diff --git a/test/Sema/format-string-percentm.c b/test/Sema/format-string-percentm.c new file mode 100644 index 0000000..f531372 --- /dev/null +++ b/test/Sema/format-string-percentm.c @@ -0,0 +1,6 @@ +// RUN: clang-cc -fsyntax-only -verify %s -triple i686-pc-linux-gnu + +int printf(char const*,...); +void percentm(void) { + printf("%m"); +} diff --git a/test/Sema/format-strings.c b/test/Sema/format-strings.c new file mode 100644 index 0000000..1826c74 --- /dev/null +++ b/test/Sema/format-strings.c @@ -0,0 +1,132 @@ +// RUN: clang-cc -fsyntax-only -verify -Wformat-nonliteral %s + +// Define this to get vasprintf on Linux +#define _GNU_SOURCE + +#include <stdio.h> +#include <stdarg.h> + +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); // // 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___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); // no-warning + vsnprintf(buf,2,s,ap); // no-warning + vsnprintf(buf,2,global_fmt,ap); // expected-warning {{format string is not a string literal}} + __builtin___vsnprintf_chk(buf,2,0,-1,s,ap); // no-warning + __builtin___vsnprintf_chk(buf,2,0,-1,global_fmt,ap); // expected-warning {{format string is not a string literal}} + + // rdar://6079877 + printf("abc" + "%*d", (unsigned) 1, 1); // expected-warning {{field width should have type 'int'}} + printf("abc\ +def" + "%*d", (unsigned) 1, 1); // expected-warning {{field width should have type 'int'}} + +} + +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}} +} + +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 {{lid conversion '%lb'}} + fprintf(fp,"%%%l"); // expected-warning {{lid conversion '%l'}} + sprintf(buf,"%%%%%ld%d%d", 1, 2, 3); // no-warning + snprintf(buf, 2, "%%%%%ld%;%d", 1, 2, 3); // expected-warning {{sion '%;'}} +} + +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,""); // expected-warning {{format string is empty}} +} + +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}} + vasprintf(&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 +} + diff --git a/test/Sema/function-pointer-sentinel-attribute.c b/test/Sema/function-pointer-sentinel-attribute.c new file mode 100644 index 0000000..0de02fa --- /dev/null +++ b/test/Sema/function-pointer-sentinel-attribute.c @@ -0,0 +1,23 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +void (*e) (int arg, const char * format, ...) __attribute__ ((__sentinel__ (1,1))); + +int main() +{ + 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/test/Sema/function-ptr.c b/test/Sema/function-ptr.c new file mode 100644 index 0000000..6b41001 --- /dev/null +++ b/test/Sema/function-ptr.c @@ -0,0 +1,11 @@ +// RUN: clang-cc %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* and function pointer}} + p = func; // expected-warning {{converts between void* and function pointer}} + + return p; // expected-warning {{converts between void* and function pointer}} +} + diff --git a/test/Sema/function-redecl.c b/test/Sema/function-redecl.c new file mode 100644 index 0000000..28593b0 --- /dev/null +++ b/test/Sema/function-redecl.c @@ -0,0 +1,127 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +// PR3588 +void g0(int, int); +void g0(); // expected-note{{previous declaration is 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; +void test_x() { + x(5); + x2(5); // expected-warning{{incompatible integer to pointer conversion passing 'int', expected 'int *'}} +} diff --git a/test/Sema/function-sentinel-attr.c b/test/Sema/function-sentinel-attr.c new file mode 100644 index 0000000..6630479 --- /dev/null +++ b/test/Sema/function-sentinel-attr.c @@ -0,0 +1,30 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +#define NULL (void*)0 + +#define ATTR __attribute__ ((__sentinel__)) + +void foo1 (int x, ...) ATTR; // expected-note {{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}} + +int main () +{ + + 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}} +} + diff --git a/test/Sema/function.c b/test/Sema/function.c new file mode 100644 index 0000000..c9d8630 --- /dev/null +++ b/test/Sema/function.c @@ -0,0 +1,89 @@ +// RUN: clang-cc %s -fsyntax-only -verify -pedantic +// PR1892 +void f(double a[restrict][5]); // should promote to restrict ptr. +void f(double (* restrict a)[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-warning {{void function 't13' should not return a value}} +} +int t14() { + return; // expected-warning {{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. +} + diff --git a/test/Sema/gnu89.c b/test/Sema/gnu89.c new file mode 100644 index 0000000..4601cbe --- /dev/null +++ b/test/Sema/gnu89.c @@ -0,0 +1,3 @@ +// RUN: clang-cc %s -std=gnu89 -pedantic -fsyntax-only -verify + +int f(int restrict); diff --git a/test/Sema/heinous-extensions-off.c b/test/Sema/heinous-extensions-off.c new file mode 100644 index 0000000..3a9880c --- /dev/null +++ b/test/Sema/heinous-extensions-off.c @@ -0,0 +1,10 @@ +// RUN: clang-cc %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/test/Sema/heinous-extensions-on.c b/test/Sema/heinous-extensions-on.c new file mode 100644 index 0000000..480b1b4 --- /dev/null +++ b/test/Sema/heinous-extensions-on.c @@ -0,0 +1,10 @@ +// RUN: clang-cc %s -verify -fheinous-gnu-extensions + +int 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/test/Sema/i-c-e.c b/test/Sema/i-c-e.c new file mode 100644 index 0000000..de27966 --- /dev/null +++ b/test/Sema/i-c-e.c @@ -0,0 +1,66 @@ +// RUN: clang-cc %s -fsyntax-only -verify -pedantic -fpascal-strings + +#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]; + + +// __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 : ( // expected-error {{expression is not an integer constant expression}} + __builtin_constant_p((int)(1.0+2.0)) ? (int)(1.0+ + expr // expected-note {{subexpression not valid in 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)]; +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 illegaldiv1[1 || 1/0]; +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}} + +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/test/Sema/if-empty-body.c b/test/Sema/if-empty-body.c new file mode 100644 index 0000000..1d1df40 --- /dev/null +++ b/test/Sema/if-empty-body.c @@ -0,0 +1,16 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +void f1(int a) { + if (a); // expected-warning {{if statement has empty body}} +} + +void f2(int a) { + if (a) {} +} + +void f3() { + if (1) + xx; // expected-error {{use of undeclared identifier}} + return; // no empty body warning. +} + diff --git a/test/Sema/illegal-types.c b/test/Sema/illegal-types.c new file mode 100644 index 0000000..c932bb2 --- /dev/null +++ b/test/Sema/illegal-types.c @@ -0,0 +1,7 @@ +// RUN: clang-cc -fsyntax-only -verify -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/test/Sema/implicit-builtin-decl.c b/test/Sema/implicit-builtin-decl.c new file mode 100644 index 0000000..696a2b9 --- /dev/null +++ b/test/Sema/implicit-builtin-decl.c @@ -0,0 +1,53 @@ +// RUN: clang-cc -fsyntax-only -verify %s +void f() { + int *ptr = malloc(sizeof(int) * 10); // expected-warning{{implicitly declaring C 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 *, char const *)'}} +} + +void f2() { + fprintf(0, "foo"); // expected-error{{implicit declaration of 'fprintf' requires inclusion of the header <stdio.h>}} +} + +// 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() { } diff --git a/test/Sema/implicit-builtin-freestanding.c b/test/Sema/implicit-builtin-freestanding.c new file mode 100644 index 0000000..9bd5c05 --- /dev/null +++ b/test/Sema/implicit-builtin-freestanding.c @@ -0,0 +1,4 @@ +// RUN: clang-cc -fsyntax-only -verify -ffreestanding %s + +int malloc(int a) { return a; } + diff --git a/test/Sema/implicit-builtin-redecl.c b/test/Sema/implicit-builtin-redecl.c new file mode 100644 index 0000000..cd99b54 --- /dev/null +++ b/test/Sema/implicit-builtin-redecl.c @@ -0,0 +1,14 @@ +// RUN: clang-cc -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' will be ignored}} \ +// expected-note{{'calloc' is a builtin with type 'void *}} + +void f1(void) { + calloc(0, 0, 0); +} diff --git a/test/Sema/implicit-cast.c b/test/Sema/implicit-cast.c new file mode 100644 index 0000000..ce34ad6 --- /dev/null +++ b/test/Sema/implicit-cast.c @@ -0,0 +1,8 @@ +// RUN: clang-cc -fsyntax-only %s + +static char *test1(int cf) { + return cf ? "abc" : 0; +} +static char *test2(int cf) { + return cf ? 0 : "abc"; +} diff --git a/test/Sema/implicit-decl.c b/test/Sema/implicit-decl.c new file mode 100644 index 0000000..8873e76 --- /dev/null +++ b/test/Sema/implicit-decl.c @@ -0,0 +1,17 @@ +// RUN: clang-cc %s -verify -fsyntax-only + +typedef int int32_t; +typedef unsigned char Boolean; + +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}} + } + return ((void *)0); // expected-warning {{void function 'func' should not return a value}} +} +Boolean _CFCalendarDecomposeAbsoluteTimeV(const char *componentDesc, int32_t **vector, int32_t count) { // expected-error{{conflicting types for '_CFCalendarDecomposeAbsoluteTimeV'}} + return 0; +} + diff --git a/test/Sema/implicit-def.c b/test/Sema/implicit-def.c new file mode 100644 index 0000000..2c25946 --- /dev/null +++ b/test/Sema/implicit-def.c @@ -0,0 +1,8 @@ +/* RUN: clang-cc -fsyntax-only %s -std=c89 && + * RUN: not clang-cc -fsyntax-only %s -std=c99 -pedantic-errors + */ + +int A() { + return X(); +} + diff --git a/test/Sema/implicit-int.c b/test/Sema/implicit-int.c new file mode 100644 index 0000000..04b27a8 --- /dev/null +++ b/test/Sema/implicit-int.c @@ -0,0 +1,31 @@ +// RUN: clang-cc -fsyntax-only %s -verify -pedantic + +foo() { // expected-warning {{type specifier missing, defaults to 'int'}} +} + +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/test/Sema/incompatible-sign.c b/test/Sema/incompatible-sign.c new file mode 100644 index 0000000..a62f9a8 --- /dev/null +++ b/test/Sema/incompatible-sign.c @@ -0,0 +1,5 @@ +// RUN: clang-cc %s -verify -fsyntax-only + +int a(int* x); +int b(unsigned* y) { return a(y); } // expected-warning {{pointer types point to integer types with different sign}} + diff --git a/test/Sema/incomplete-call.c b/test/Sema/incomplete-call.c new file mode 100644 index 0000000..aedfe50 --- /dev/null +++ b/test/Sema/incomplete-call.c @@ -0,0 +1,13 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +struct foo; // expected-note 3 {{forward declaration of 'struct foo'}} + +struct foo a(); +void b(struct foo); +void c(); + +void func() { + a(); // expected-error{{return type of called function ('struct foo') is incomplete}} + b(*(struct foo*)0); // expected-error{{argument type 'struct foo' is incomplete}} + c(*(struct foo*)0); // expected-error{{argument type 'struct foo' is incomplete}} +} diff --git a/test/Sema/incomplete-decl.c b/test/Sema/incomplete-decl.c new file mode 100644 index 0000000..eb93e8e --- /dev/null +++ b/test/Sema/incomplete-decl.c @@ -0,0 +1,30 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +struct foo; // expected-note 4 {{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-error {{variable has incomplete type 'struct foo'}} + +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{{variable has incomplete type 'int []'}} + 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 pointer to 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/test/Sema/indirect-goto.c b/test/Sema/indirect-goto.c new file mode 100644 index 0000000..35fb5e6 --- /dev/null +++ b/test/Sema/indirect-goto.c @@ -0,0 +1,8 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +struct c {int x;}; +int a(struct c x, long long y) { + goto *x; // expected-error{{incompatible type}} + goto *y; // expected-warning{{incompatible integer to pointer conversion}} +} + diff --git a/test/Sema/init-struct-qualified.c b/test/Sema/init-struct-qualified.c new file mode 100644 index 0000000..539820a --- /dev/null +++ b/test/Sema/init-struct-qualified.c @@ -0,0 +1,12 @@ +// RUN: clang-cc -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/test/Sema/init.c b/test/Sema/init.c new file mode 100644 index 0000000..1cbcbb7 --- /dev/null +++ b/test/Sema/init.c @@ -0,0 +1,128 @@ +// RUN: clang-cc %s -verify -fsyntax-only + +#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; + +int test() { +int a[10]; +int b[10] = a; // expected-error {{initialization with '{...}' expected}} +int +; // expected-error {{expected identifier or '('}} expected-error {{expected ';' at end of declaration}} +} + + +// 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 = { + .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}); +ivector4 vtest3 = __real__ (ivector4){1}; +ivector4 vtest4 = __imag__ (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"; diff --git a/test/Sema/inline.c b/test/Sema/inline.c new file mode 100644 index 0000000..adcde51 --- /dev/null +++ b/test/Sema/inline.c @@ -0,0 +1,6 @@ +// RUN: clang-cc -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/test/Sema/int-arith-convert.c b/test/Sema/int-arith-convert.c new file mode 100644 index 0000000..5bbab7d --- /dev/null +++ b/test/Sema/int-arith-convert.c @@ -0,0 +1,12 @@ +// RUN: clang-cc -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/test/Sema/invalid-decl.c b/test/Sema/invalid-decl.c new file mode 100644 index 0000000..8c45800 --- /dev/null +++ b/test/Sema/invalid-decl.c @@ -0,0 +1,22 @@ +// RUN: clang-cc %s -fsyntax-only -verify + +void test() { + char = 4; // expected-error {{expected identifier}} +} + + +// PR2400 +typedef xtype (*x)(void* handle); // expected-error {{function cannot return array or 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/test/Sema/invalid-init-diag.c b/test/Sema/invalid-init-diag.c new file mode 100644 index 0000000..724d0ea --- /dev/null +++ b/test/Sema/invalid-init-diag.c @@ -0,0 +1,4 @@ +// RUN: clang-cc %s -verify -fsyntax-only + +int a; +struct {int x;} x = a; // expected-error {{incompatible type initializing 'int', expected 'struct <anonymous>'}} diff --git a/test/Sema/invalid-struct-init.c b/test/Sema/invalid-struct-init.c new file mode 100644 index 0000000..73e2e44 --- /dev/null +++ b/test/Sema/invalid-struct-init.c @@ -0,0 +1,29 @@ +// RUN: clang-cc %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-error{{field '_efree' declared as a function}} \ + expected-warning {{type specifier missing, defaults to 'int'}} \ + 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/test/Sema/knr-def-call.c b/test/Sema/knr-def-call.c new file mode 100644 index 0000000..6b033fc --- /dev/null +++ b/test/Sema/knr-def-call.c @@ -0,0 +1,18 @@ +// RUN: clang-cc -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 diff --git a/test/Sema/knr-variadic-def.c b/test/Sema/knr-variadic-def.c new file mode 100644 index 0000000..070ba07 --- /dev/null +++ b/test/Sema/knr-variadic-def.c @@ -0,0 +1,29 @@ +// RUN: clang-cc -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/test/Sema/member-reference.c b/test/Sema/member-reference.c new file mode 100644 index 0000000..b810ccf --- /dev/null +++ b/test/Sema/member-reference.c @@ -0,0 +1,20 @@ +// RUN: clang-cc %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/test/Sema/merge-decls.c b/test/Sema/merge-decls.c new file mode 100644 index 0000000..f4c25f5 --- /dev/null +++ b/test/Sema/merge-decls.c @@ -0,0 +1,39 @@ +// RUN: clang-cc %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/test/Sema/ms-fuzzy-asm.c b/test/Sema/ms-fuzzy-asm.c new file mode 100644 index 0000000..58dcbcf --- /dev/null +++ b/test/Sema/ms-fuzzy-asm.c @@ -0,0 +1,9 @@ +// RUN: clang-cc %s -verify -fms-extensions + +#define M __asm int 0x2c +#define M2 int + +void t1(void) { M } +void t2(void) { __asm int 0x2c } +void t3(void) { __asm M2 0x2c } + diff --git a/test/Sema/nested-redef.c b/test/Sema/nested-redef.c new file mode 100644 index 0000000..ea18091 --- /dev/null +++ b/test/Sema/nested-redef.c @@ -0,0 +1,22 @@ +// RUN: clang-cc -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/test/Sema/nonnull.c b/test/Sema/nonnull.c new file mode 100644 index 0000000..3bed2fe --- /dev/null +++ b/test/Sema/nonnull.c @@ -0,0 +1,32 @@ +// RUN: clang-cc -fblocks -fsyntax-only -verify %s + +int f1(int x) __attribute__((nonnull)); // expected-warning{{'nonnull' attribute applied to function with no pointer arguments}} +int f2(int *x) __attribute__ ((nonnull (1))); +int f3(int *x) __attribute__ ((nonnull (0))); // expected-error {{'nonnull' attribute parameter 1 is out of bounds}} +int f4(int *x, int *y) __attribute__ ((nonnull (1,2))); +int f5(int *x, int *y) __attribute__ ((nonnull (2,1))); + +extern void func1 (void (^block1)(), void (^block2)(), int) __attribute__((nonnull)); + +extern void func3 (void (^block1)(), int, void (^block2)(), int) +__attribute__((nonnull(1,3))); + +extern void func4 (void (^block1)(), void (^block2)()) __attribute__((nonnull(1))) +__attribute__((nonnull(2))); + +void +foo (int i1, int i2, int i3, void (^cp1)(), void (^cp2)(), void (^cp3)()) +{ + func1(cp1, cp2, i1); + + func1(0, cp2, i1); // expected-warning {{null passed to a callee which requires a non-null argument}} + func1(cp1, 0, i1); // expected-warning {{null passed to a callee which requires a non-null argument}} + func1(cp1, cp2, 0); + + + func3(0, i2, cp3, i3); // expected-warning {{null passed to a callee which requires a non-null argument}} + func3(cp3, i2, 0, i3); // expected-warning {{null passed to a callee which requires a non-null argument}} + + func4(0, cp1); // expected-warning {{null passed to a callee which requires a non-null argument}} + func4(cp1, 0); // expected-warning {{null passed to a callee which requires a non-null argument}} +} diff --git a/test/Sema/offsetof.c b/test/Sema/offsetof.c new file mode 100644 index 0000000..f8b9fed --- /dev/null +++ b/test/Sema/offsetof.c @@ -0,0 +1,50 @@ +// RUN: clang-cc -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)]; diff --git a/test/Sema/overloadable-complex.c b/test/Sema/overloadable-complex.c new file mode 100644 index 0000000..62b3882 --- /dev/null +++ b/test/Sema/overloadable-complex.c @@ -0,0 +1,50 @@ +// RUN: clang-cc -fsyntax-only -verify %s +char *foo(float) __attribute__((__overloadable__)); // expected-note 3 {{candidate function}} + +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__)); // expected-note 3 {{candidate function}} + +void test_foo_2(float fv, double dv, float _Complex fc, double _Complex dc) { + char *cp1 = foo(fv); + char *cp2 = foo(dv); // expected-error{{call to 'foo' is ambiguous; candidates are:}} + int *ip = foo(fc); + int *lp = foo(dc); // expected-error{{call to 'foo' is ambiguous; candidates are:}} +} + +long *foo(double _Complex) __attribute__((__overloadable__)); // expected-note {{candidate function}} + +void test_foo_3(float fv, double dv, float _Complex fc, double _Complex dc) { + char *cp1 = foo(fv); + char *cp2 = foo(dv); // expected-error{{call to 'foo' is ambiguous; candidates are:}} + 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; candidates are:}} + int *ip2 = promote_or_convert(f); // expected-error{{call to 'promote_or_convert' is ambiguous; candidates are:}} +} + +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/test/Sema/overloadable.c b/test/Sema/overloadable.c new file mode 100644 index 0000000..0d5db3a --- /dev/null +++ b/test/Sema/overloadable.c @@ -0,0 +1,53 @@ +// RUN: clang-cc -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'; candidates are:}} +} + +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__)); +double promote(double) __attribute__((__overloadable__)); +long double promote(long double) __attribute__((__overloadable__)); + +void promote() __attribute__((__overloadable__)); // expected-error{{'overloadable' function 'promote' must have a prototype}} +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'}} +} + + diff --git a/test/Sema/pointer-addition.c b/test/Sema/pointer-addition.c new file mode 100644 index 0000000..87d5eaf --- /dev/null +++ b/test/Sema/pointer-addition.c @@ -0,0 +1,19 @@ +// RUN: clang-cc %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 pointer to incomplete type}} + b += 1; // expected-error {{arithmetic on pointer to incomplete type}} + c++; // expected-warning {{use of GNU void* extension}} + c += 1; // expected-warning {{use of GNU void* extension}} + c--; // expected-warning {{use of GNU void* extension}} + c -= 1; // expected-warning {{use of GNU void* extension}} + b = 1+b; // expected-error {{arithmetic on pointer to incomplete type}} + /* The next couple tests are only pedantic warnings in gcc */ + void (*d)(S*,void*) = a; + d += 1; // expected-warning {{arithmetic on pointer to function type 'void (*)(S *, void *)' is a GNU extension}} + d++; // expected-warning {{arithmetic on pointer to function type 'void (*)(S *, void *)' is a GNU extension}}} + d--; // expected-warning {{arithmetic on pointer to function type 'void (*)(S *, void *)' is a GNU extension}} + d -= 1; // expected-warning {{arithmetic on pointer to function type 'void (*)(S *, void *)' is a GNU extension}} +} diff --git a/test/Sema/pointer-subtract-compat.c b/test/Sema/pointer-subtract-compat.c new file mode 100644 index 0000000..b3be37e --- /dev/null +++ b/test/Sema/pointer-subtract-compat.c @@ -0,0 +1,11 @@ +// RUN: clang-cc %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 pointer to function type 'void (*)(void)' is a GNU extension}} +} diff --git a/test/Sema/pragma-pack-2.c b/test/Sema/pragma-pack-2.c new file mode 100644 index 0000000..25be553 --- /dev/null +++ b/test/Sema/pragma-pack-2.c @@ -0,0 +1,93 @@ +// RUN: clang-cc -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) + +// Test scope of definition + +#pragma pack(push, 2) +struct s2_0 { +#pragma pack(pop) + char f0; + int f1; +}; +extern int a2_0[offsetof(struct s2_0, f1) == 2 ? 1 : -1]; + +struct s2_1 { + char f0; +#pragma pack(push, 2) + int f1; +#pragma pack(pop) +}; +extern int a2_1[offsetof(struct s2_1, f1) == 4 ? 1 : -1]; + +struct s2_2 { + char f0; + int f1; +#pragma pack(push, 2) +}; +#pragma pack(pop) +extern int a2_2[offsetof(struct s2_2, f1) == 4 ? 1 : -1]; + +struct s2_3 { + char f0; +#pragma pack(push, 2) + struct s2_3_0 { +#pragma pack(pop) + int f0; + } f1; +}; +extern int a2_3[offsetof(struct s2_3, f1) == 2 ? 1 : -1]; + +struct s2_4 { + char f0; + struct s2_4_0 { + int f0; +#pragma pack(push, 2) + } f1; +#pragma pack(pop) +}; +extern int a2_4[offsetof(struct s2_4, f1) == 4 ? 1 : -1]; + +#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]; diff --git a/test/Sema/pragma-pack-3.c b/test/Sema/pragma-pack-3.c new file mode 100644 index 0000000..a2d665e --- /dev/null +++ b/test/Sema/pragma-pack-3.c @@ -0,0 +1,34 @@ +// RUN: clang-cc -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/test/Sema/pragma-pack.c b/test/Sema/pragma-pack.c new file mode 100644 index 0000000..51398fa --- /dev/null +++ b/test/Sema/pragma-pack.c @@ -0,0 +1,27 @@ +// RUN: clang-cc -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/test/Sema/pragma-unused.c b/test/Sema/pragma-unused.c new file mode 100644 index 0000000..fe8bf86 --- /dev/null +++ b/test/Sema/pragma-unused.c @@ -0,0 +1,38 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +void f1(void) { + int x, y, z; + #pragma unused(x) + #pragma unused(y, z) + + int w; // FIXME: We should emit a warning that 'w' is unused. + #pragma unused w // expected-warning{{missing '(' after '#pragma unused' - ignoring}} +} + +void f2(void) { + int x, y; + #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-error{{use of undeclared identifier 'x'}} +} + +void f4(void) { + int w; // FIXME: We should emit a warning that 'w' is unused. + #pragma unused((w)) // expected-warning{{expected '#pragma unused' argument to be a variable name}} +} + +int k; +void f5(void) { + #pragma unused(k) // expected-warning{{only local variables can be arguments to '#pragma unused' - ignored}} +} + +void f6(void) { + int z; // no-warning + { + #pragma unused(z) // no-warning + } +} + diff --git a/test/Sema/predef.c b/test/Sema/predef.c new file mode 100644 index 0000000..7b3fe50 --- /dev/null +++ b/test/Sema/predef.c @@ -0,0 +1,19 @@ +// RUN: clang-cc -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 const [1]' discards qualifiers, expected 'char *'}} + +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/test/Sema/predefined-function.c b/test/Sema/predefined-function.c new file mode 100644 index 0000000..e8ccb36 --- /dev/null +++ b/test/Sema/predefined-function.c @@ -0,0 +1,38 @@ +// RUN: clang-cc -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}} +int b(int c) {return 1;} + +int foo(); +int foo() +{ + int eli(int (int)); // expected-error {{conflicting types for 'eli'}} + eli(b); // expected-error{{incompatible type passing}} + 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/test/Sema/private-extern.c b/test/Sema/private-extern.c new file mode 100644 index 0000000..5dd37f4 --- /dev/null +++ b/test/Sema/private-extern.c @@ -0,0 +1,88 @@ +// RUN: clang-cc -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() { + // FIXME: Diagnose this? + int g6; + extern int g6; +} + +void f1() { + // FIXME: Diagnose this? + int g7; + __private_extern__ int g7; +} + +void f2() { + extern int g8; // expected-note{{previous definition}} + // FIXME: Improve this diagnostic. + int g8; // expected-error{{redefinition of 'g8'}} +} + +void f3() { + __private_extern__ int g9; // expected-note{{previous definition}} + // FIXME: Improve this diagnostic. + int g9; // expected-error{{redefinition of 'g9'}} +} + +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/test/Sema/rdar6248119.m b/test/Sema/rdar6248119.m new file mode 100644 index 0000000..631c7b3 --- /dev/null +++ b/test/Sema/rdar6248119.m @@ -0,0 +1,27 @@ +// RUN: clang-cc -fsyntax-only %s -verify +// Test case for: +// <rdar://problem/6248119> @finally doesn't introduce a new scope + +void f0() { + int i; + @try { + } @finally { + int i = 0; + } +} + +void f1() { + int i; + @try { + int i =0; + } @finally { + } +} + +void f2() { + int i; + @try { + } @catch(id e) { + int i = 0; + } +} diff --git a/test/Sema/rdr6094103-unordered-compare-promote.c b/test/Sema/rdr6094103-unordered-compare-promote.c new file mode 100644 index 0000000..636f770 --- /dev/null +++ b/test/Sema/rdr6094103-unordered-compare-promote.c @@ -0,0 +1,6 @@ +// RUN: clang-cc -ast-dump %s 2>&1 | grep ImplicitCastExpr | count 2 + +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/test/Sema/recover-goto.c b/test/Sema/recover-goto.c new file mode 100644 index 0000000..e7b9f3c --- /dev/null +++ b/test/Sema/recover-goto.c @@ -0,0 +1,4 @@ +// RUN: clang-cc -fsyntax-only %s -verify + +void a() {goto A; // expected-error {{use of undeclared label}} +// expected-error {{expected '}'}} diff --git a/test/Sema/redefinition.c b/test/Sema/redefinition.c new file mode 100644 index 0000000..26c90c8 --- /dev/null +++ b/test/Sema/redefinition.c @@ -0,0 +1,10 @@ +// RUN: clang-cc %s -fsyntax-only -verify +int f(int a) { } // expected-note {{previous definition is here}} +int f(int); +int f(int a) { } // expected-error {{redefinition of 'f'}} + +// <rdar://problem/6097326> +int foo(x) { + return 0; +} +int x = 1; diff --git a/test/Sema/return-silent.c b/test/Sema/return-silent.c new file mode 100644 index 0000000..b3b2a56 --- /dev/null +++ b/test/Sema/return-silent.c @@ -0,0 +1,9 @@ +// RUN: clang-cc %s -Wno-return-type -fsyntax-only -verify + +int t14() { + return; +} + +void t15() { + return 1; +} diff --git a/test/Sema/return.c b/test/Sema/return.c new file mode 100644 index 0000000..d96cede --- /dev/null +++ b/test/Sema/return.c @@ -0,0 +1,12 @@ +// RUN: clang-cc %s -fsyntax-only -verify + +// 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}} +} diff --git a/test/Sema/scope-check.c b/test/Sema/scope-check.c new file mode 100644 index 0000000..76041c4 --- /dev/null +++ b/test/Sema/scope-check.c @@ -0,0 +1,196 @@ +// RUN: clang-cc -fsyntax-only -verify -fblocks -std=gnu99 %s + +int test1(int x) { + goto L; // expected-error{{illegal 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{{illegal 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{{illegal goto into protected scope}} +int a __attribute((cleanup(test3clean))); // expected-note {{jump bypasses initialization of declaration with __attribute__((cleanup))}} +L: + return a; +} + +int test4(int x) { + goto L; // expected-error{{illegal 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 {{illegal switch case into protected scope}} + a[1] = 2; + break; + } +} + +int test8(int x) { + // For statement. + goto L2; // expected-error {{illegal 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 {{illegal goto into protected scope}} + int Y = ({ int a[x]; // expected-note {{jump bypasses initialization of variable length array}} + L3: 4; }); + + goto L4; // expected-error {{illegal 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 {{illegal 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 {{illegal 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 {{illegal 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; // ok. + +L2: ; + int a[n]; // expected-note 2 {{jump bypasses initialization of variable length array}} + +L3: +L4: + goto *P; // expected-error {{illegal indirect goto in protected scope, unknown effect on scopes}} + goto L3; // ok + goto L4; // ok + + void *Ptrs[] = { + &&L2, // Ok. + &&L3 // expected-error {{address taken of label in protected scope, jump to it would have unknown effect on scope}} + }; +} + +void test10(int n, void *P) { + goto L0; // expected-error {{illegal goto into protected scope}} + typedef int A[n]; // expected-note {{jump bypasses initialization of VLA typedef}} +L0: + + goto L1; // expected-error {{illegal goto into protected scope}} + A b, c[10]; // expected-note 2 {{jump bypasses initialization of variable length array}} +L1: + goto L2; // expected-error {{illegal 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 {{illegal switch case into protected scope}} + return; + } + }; +} + + +// TODO: When and if gotos are allowed in blocks, this should work. +void test12(int n) { + void *P = ^{ + goto L1; // expected-error {{goto not allowed in block literal}} + L1: + goto L2; // expected-error {{goto not allowed in block literal}} + L2: + goto L3; // expected-error {{goto not allowed in block literal}} + // todo-error {{illegal goto into protected scope}} + int Arr[n]; // todo-note {{jump bypasses initialization of variable length array}} + L3: + goto L4; // expected-error {{goto not allowed in block literal}} + L4: return; + }; +} + diff --git a/test/Sema/self-comparison.c b/test/Sema/self-comparison.c new file mode 100644 index 0000000..db56e8b --- /dev/null +++ b/test/Sema/self-comparison.c @@ -0,0 +1,33 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +int foo(int x) { + return x == x; // expected-warning {{self-comparison always results}} +} + +int foo2(int x) { + return (x) != (((x))); // expected-warning {{self-comparison always results}} +} + +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 +} + +// Motivated by <rdar://problem/6703892>, self-comparisons of enum constants +// should not be warned about. These can be expanded from macros, and thus +// are usually deliberate. +int compare_enum() { + enum { A }; + return A == A; // no-warning +} diff --git a/test/Sema/sentinel-attribute.c b/test/Sema/sentinel-attribute.c new file mode 100644 index 0000000..c40f8df --- /dev/null +++ b/test/Sema/sentinel-attribute.c @@ -0,0 +1,15 @@ +// RUN: clang-cc -fsyntax-only -verify %s +int x __attribute__((sentinel)); //expected-warning{{'sentinel' attribute only applies to function, method or block types}} + +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 requires 0, 1 or 2 argument(s)}} +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/test/Sema/shift.c b/test/Sema/shift.c new file mode 100644 index 0000000..5acbe12 --- /dev/null +++ b/test/Sema/shift.c @@ -0,0 +1,6 @@ +// RUN: clang-cc -fsyntax-only %s + +void test() { + char c; + c <<= 14; +} diff --git a/test/Sema/statements.c b/test/Sema/statements.c new file mode 100644 index 0000000..9a71a40 --- /dev/null +++ b/test/Sema/statements.c @@ -0,0 +1,29 @@ +// RUN: clang-cc %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 {{incompatible type returning 'void', expected '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); +} diff --git a/test/Sema/static-init.c b/test/Sema/static-init.c new file mode 100644 index 0000000..cd49556 --- /dev/null +++ b/test/Sema/static-init.c @@ -0,0 +1,23 @@ +// RUN: clang-cc -triple i386-pc-linux-gnu -fsyntax-only -verify %s + +#include <stdint.h> + +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 { + unsigned ptr; +}; + +union bar u[1]; +struct foo x = {(intptr_t) u}; // no-error +struct foo y = {(char) u}; // expected-error {{initializer element is not a compile-time constant}} diff --git a/test/Sema/stdcall-fastcall.c b/test/Sema/stdcall-fastcall.c new file mode 100644 index 0000000..353bbfc --- /dev/null +++ b/test/Sema/stdcall-fastcall.c @@ -0,0 +1,10 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +// CC qualifier can be applied only to functions +int __attribute__((stdcall)) var1; // expected-warning{{'stdcall' attribute only applies to function types}} +int __attribute__((fastcall)) var2; // expected-warning{{'fastcall' attribute only applies to function types}} + +// Different CC qualifiers are not compatible +void __attribute__((stdcall, fastcall)) foo3(); // expected-error{{stdcall and fastcall attributes are not compatible}} +void __attribute__((stdcall)) foo4(); +void __attribute__((fastcall)) foo4(); // expected-error{{fastcall and stdcall attributes are not compatible}} diff --git a/test/Sema/struct-cast.c b/test/Sema/struct-cast.c new file mode 100644 index 0000000..063e8e3 --- /dev/null +++ b/test/Sema/struct-cast.c @@ -0,0 +1,14 @@ +// RUN: clang-cc -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/test/Sema/struct-compat.c b/test/Sema/struct-compat.c new file mode 100644 index 0000000..35d8fb1 --- /dev/null +++ b/test/Sema/struct-compat.c @@ -0,0 +1,17 @@ +/* RUN: clang-cc %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 {{incompatible type initializing}} +} diff --git a/test/Sema/struct-decl.c b/test/Sema/struct-decl.c new file mode 100644 index 0000000..2c0945f --- /dev/null +++ b/test/Sema/struct-decl.c @@ -0,0 +1,43 @@ +// RUN: clang-cc -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{{array size is negative}} +}; + +// 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) {} diff --git a/test/Sema/struct-packed-align.c b/test/Sema/struct-packed-align.c new file mode 100644 index 0000000..8250c14 --- /dev/null +++ b/test/Sema/struct-packed-align.c @@ -0,0 +1,111 @@ +// RUN: clang-cc %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]; + +// 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]; diff --git a/test/Sema/surpress-deprecated.c b/test/Sema/surpress-deprecated.c new file mode 100644 index 0000000..8dbe9dd --- /dev/null +++ b/test/Sema/surpress-deprecated.c @@ -0,0 +1,7 @@ +// RUN: clang -fsyntax-only -Wno-deprecated-declarations -verify %s +extern void OldFunction() __attribute__((deprecated)); + +int main (int argc, const char * argv[]) { + OldFunction(); +} + diff --git a/test/Sema/switch.c b/test/Sema/switch.c new file mode 100644 index 0000000..5999f34 --- /dev/null +++ b/test/Sema/switch.c @@ -0,0 +1,70 @@ +// RUN: clang-cc -fsyntax-only -verify %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); +} + +extern int g(); + +void test4() +{ + switch (1) { + case 0 && g(): + case 1 || g(): + break; + } + + switch(1) { + 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 (1) { + case 0 && g() ... 1 || g(): + break; + } + + switch (1) { + case g() && 0: // expected-error {{expression is not an integer constant expression}} // expected-note {{subexpression not valid in an integer constant expression}} + break; + } + + switch (1) { + case 0 ... g() || 1: // expected-error {{expression is not an integer constant expression}} // expected-note {{subexpression not valid in an integer constant expression}} + break; + } +} + +void test5(int z) { + switch(z) { + default: // expected-note {{previous case defined here}} + default: // expected-error {{multiple default labels in one switch}} + break; + } +} + diff --git a/test/Sema/tentative-decls.c b/test/Sema/tentative-decls.c new file mode 100644 index 0000000..e3c893c --- /dev/null +++ b/test/Sema/tentative-decls.c @@ -0,0 +1,65 @@ +// RUN: clang-cc %s -fsyntax-only -verify + +// PR3310 +struct a x1; // expected-note 2{{forward declaration of 'struct a'}} +static struct a x2; // expected-error{{variable has incomplete 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/test/Sema/text-diag.c b/test/Sema/text-diag.c new file mode 100644 index 0000000..19847c6 --- /dev/null +++ b/test/Sema/text-diag.c @@ -0,0 +1,4 @@ +// RUN: clang-cc -fsyntax-only %s +unsigned char *foo = "texto\ +que continua\ +e continua"; diff --git a/test/Sema/thread-specifier.c b/test/Sema/thread-specifier.c new file mode 100644 index 0000000..8d66e53 --- /dev/null +++ b/test/Sema/thread-specifier.c @@ -0,0 +1,21 @@ +// RUN: clang-cc -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/test/Sema/transparent-union-pointer.c b/test/Sema/transparent-union-pointer.c new file mode 100644 index 0000000..ea761f1 --- /dev/null +++ b/test/Sema/transparent-union-pointer.c @@ -0,0 +1,14 @@ +// RUN: clang-cc %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/test/Sema/transparent-union.c b/test/Sema/transparent-union.c new file mode 100644 index 0000000..90ecaad --- /dev/null +++ b/test/Sema/transparent-union.c @@ -0,0 +1,40 @@ +// RUN: clang -fsyntax-only -Xclang -verify %s +typedef union { + int *ip; + float *fp; +} TU __attribute__((transparent_union)); + +void f(TU); + +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; +} + +/* 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}} diff --git a/test/Sema/type-spec-struct-union.c b/test/Sema/type-spec-struct-union.c new file mode 100644 index 0000000..2b68b78 --- /dev/null +++ b/test/Sema/type-spec-struct-union.c @@ -0,0 +1,65 @@ +// RUN: clang-cc -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; +}; +int +wizbiz_quxPoof(z) + z_foop z; +{ + z->baz->mode = z->baz->nowrap ? HOP : SQUAT; +} diff --git a/test/Sema/typecheck-binop.c b/test/Sema/typecheck-binop.c new file mode 100644 index 0000000..f5bdcbb --- /dev/null +++ b/test/Sema/typecheck-binop.c @@ -0,0 +1,27 @@ +/* RUN: clang-cc %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{{subtraction of pointer 'struct incomplete *' requires pointee to be a complete object type}} */ +} + +void *sub3(void *P) { + return P-4; /* expected-warning{{GNU void* extension}} */ +} + +int sub4(void *P, void *Q) { + return P-Q; /* expected-warning{{GNU void* 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/test/Sema/typedef-prototype.c b/test/Sema/typedef-prototype.c new file mode 100644 index 0000000..fc0e05e --- /dev/null +++ b/test/Sema/typedef-prototype.c @@ -0,0 +1,8 @@ +// RUN: clang-cc -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/test/Sema/typedef-redef.c b/test/Sema/typedef-redef.c new file mode 100644 index 0000000..9a1c488 --- /dev/null +++ b/test/Sema/typedef-redef.c @@ -0,0 +1,11 @@ +// RUN: clang-cc -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/test/Sema/typedef-retain.c b/test/Sema/typedef-retain.c new file mode 100644 index 0000000..ef9ec76 --- /dev/null +++ b/test/Sema/typedef-retain.c @@ -0,0 +1,38 @@ +// RUN: clang-cc -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 'float4', expected 'int4'}} +} + +void test2(float4 a, int4p result, int i) { + result[i] = a; // expected-error {{assigning 'float4', expected 'int4'}} +} + +// 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}} +} + +// PR2189 +int test5() { + const int s[5]; int t[5]; + return &s == &t; // expected-warning {{comparison of distinct pointer types}} +} + +int test6() { + const a s; + a t; + return &s == &t; // expected-warning {{comparison of distinct pointer types}} +} + diff --git a/test/Sema/typedef-variable-type.c b/test/Sema/typedef-variable-type.c new file mode 100644 index 0000000..7a9bb48 --- /dev/null +++ b/test/Sema/typedef-variable-type.c @@ -0,0 +1,3 @@ +// RUN: clang-cc %s -verify -fsyntax-only -pedantic + +typedef int (*a)[!.0]; // expected-warning{{size of static array must be an integer constant expression}} diff --git a/test/Sema/types.c b/test/Sema/types.c new file mode 100644 index 0000000..e7d4b00 --- /dev/null +++ b/test/Sema/types.c @@ -0,0 +1,39 @@ +// RUN: clang-cc %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; +} + + +// 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 type}} diff --git a/test/Sema/ucn-cstring.c b/test/Sema/ucn-cstring.c new file mode 100644 index 0000000..6d021fd --- /dev/null +++ b/test/Sema/ucn-cstring.c @@ -0,0 +1,17 @@ +// RUN: clang-cc %s -verify -fsyntax-only -pedantic + +#include <stdio.h> + +int main(void) { + int a[sizeof("hello \u2192 \u2603 \u2190 world") == 24 ? 1 : -1]; + + printf("%s (%d)\n", "hello \u2192 \u2603 \u2190 world", sizeof("hello \u2192 \u2603 \u2190 world")); + printf("%s (%d)\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{{invalid universal character}} + return 0; +} + diff --git a/test/Sema/unnamed-bitfield-init.c b/test/Sema/unnamed-bitfield-init.c new file mode 100644 index 0000000..249f06e --- /dev/null +++ b/test/Sema/unnamed-bitfield-init.c @@ -0,0 +1,6 @@ +// RUN: clang-cc -fsyntax-only -verify %s +typedef struct { + int a; int : 24; char b; +} S; + +S a = { 1, 2 }; diff --git a/test/Sema/unused-expr.c b/test/Sema/unused-expr.c new file mode 100644 index 0000000..9c231e9 --- /dev/null +++ b/test/Sema/unused-expr.c @@ -0,0 +1,46 @@ +// RUN: clang-cc -fsyntax-only -verify -fmath-errno=0 %s + +int foo(int X, int Y); + +double sqrt(double X); // implicitly const because of -fno-math-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 -fno-math-errno. + sqrt(A); // expected-warning {{expression result unused}} +} + +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; +} diff --git a/test/Sema/usual-float.c b/test/Sema/usual-float.c new file mode 100644 index 0000000..40c0bde --- /dev/null +++ b/test/Sema/usual-float.c @@ -0,0 +1,12 @@ +// RUN: clang-cc %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/test/Sema/va_arg_x86_32.c b/test/Sema/va_arg_x86_32.c new file mode 100644 index 0000000..850d324 --- /dev/null +++ b/test/Sema/va_arg_x86_32.c @@ -0,0 +1,6 @@ +// RUN: clang-cc -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/test/Sema/va_arg_x86_64.c b/test/Sema/va_arg_x86_64.c new file mode 100644 index 0000000..680abb7 --- /dev/null +++ b/test/Sema/va_arg_x86_64.c @@ -0,0 +1,16 @@ +// RUN: clang-cc -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 char *f (char * (*g) (char **, int), char **p, ...) { + char *s; + va_list v; + s = g (p, __builtin_va_arg(v, int)); +} + diff --git a/test/Sema/var-redecl.c b/test/Sema/var-redecl.c new file mode 100644 index 0000000..129fd17 --- /dev/null +++ b/test/Sema/var-redecl.c @@ -0,0 +1,61 @@ +// RUN: clang-cc -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) { + extern int g19; +} +int *p=&g19; // expected-error{{use of undeclared identifier 'g19'}} + +// PR3645 +static int a; +extern int a; +int a; diff --git a/test/Sema/varargs-x86-64.c b/test/Sema/varargs-x86-64.c new file mode 100644 index 0000000..7c71c96 --- /dev/null +++ b/test/Sema/varargs-x86-64.c @@ -0,0 +1,8 @@ +// RUN: clang-cc -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 '__builtin_va_list const' and not 'va_list'}} +} + diff --git a/test/Sema/varargs.c b/test/Sema/varargs.c new file mode 100644 index 0000000..8d2f0b1 --- /dev/null +++ b/test/Sema/varargs.c @@ -0,0 +1,63 @@ +// RUN: clang-cc -fsyntax-only -verify %s && +// RUN: clang-cc -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); +} + diff --git a/test/Sema/variadic-block.c b/test/Sema/variadic-block.c new file mode 100644 index 0000000..29f597b --- /dev/null +++ b/test/Sema/variadic-block.c @@ -0,0 +1,41 @@ +// RUN: clang-cc %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/test/Sema/vector-assign.c b/test/Sema/vector-assign.c new file mode 100644 index 0000000..5162e1a --- /dev/null +++ b/test/Sema/vector-assign.c @@ -0,0 +1,45 @@ +// RUN: clang-cc %s -verify -fsyntax-only -Wvector-conversions +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 f() { + v2s v1; + v2u v2; + v1s v3; + v2f v4; + v4ss v5; + + v1 = v2; // expected-warning {{incompatible vector types assigning 'v2u', expected 'v2s'}} + v1 = v3; // expected-error {{incompatible type assigning 'v1s', expected 'v2s'}} + v1 = v4; // expected-warning {{incompatible vector types assigning 'v2f', expected 'v2s'}} + v1 = v5; // expected-warning {{incompatible vector types assigning 'v4ss', expected 'v2s'}} + + v2 = v1; // expected-warning {{incompatible vector types assigning 'v2s', expected 'v2u'}} + v2 = v3; // expected-error {{incompatible type assigning 'v1s', expected 'v2u'}} + v2 = v4; // expected-warning {{incompatible vector types assigning 'v2f', expected 'v2u'}} + v2 = v5; // expected-warning {{incompatible vector types assigning 'v4ss', expected 'v2u'}} + + v3 = v1; // expected-error {{incompatible type assigning 'v2s', expected 'v1s'}} + v3 = v2; // expected-error {{incompatible type assigning 'v2u', expected 'v1s'}} + v3 = v4; // expected-error {{incompatible type assigning 'v2f', expected 'v1s'}} + v3 = v5; // expected-error {{incompatible type assigning 'v4ss', expected 'v1s'}} + + v4 = v1; // expected-warning {{incompatible vector types assigning 'v2s', expected 'v2f'}} + v4 = v2; // expected-warning {{incompatible vector types assigning 'v2u', expected 'v2f'}} + v4 = v3; // expected-error {{incompatible type assigning 'v1s', expected 'v2f'}} + v4 = v5; // expected-warning {{incompatible vector types assigning 'v4ss', expected 'v2f'}} + + v5 = v1; // expected-warning {{incompatible vector types assigning 'v2s', expected 'v4ss'}} + v5 = v2; // expected-warning {{incompatible vector types assigning 'v2u', expected 'v4ss'}} + v5 = v3; // expected-error {{incompatible type assigning 'v1s', expected 'v4ss'}} + v5 = v4; // expected-warning {{incompatible vector types assigning 'v2f', expected 'v4ss'}} +} + +// PR2263 +float f2(__attribute__((vector_size(16))) float a, int b) { + return a[b]; +} + diff --git a/test/Sema/vector-cast.c b/test/Sema/vector-cast.c new file mode 100644 index 0000000..bd09e69 --- /dev/null +++ b/test/Sema/vector-cast.c @@ -0,0 +1,38 @@ +// RUN: clang-cc -fsyntax-only %s -verify -Wvector-conversions + +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 \ +'t1' and 't2' of different size}} + v1 = (t1)v2; // -expected-error {{invalid conversion between vector type \ +'t2' and 't1' 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 'int' 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); + +void f3(t3 Y) { + f2(Y); // expected-warning {{incompatible vector types passing 't3', expected 't2'}} +} + diff --git a/test/Sema/vector-init.c b/test/Sema/vector-init.c new file mode 100644 index 0000000..6eab324 --- /dev/null +++ b/test/Sema/vector-init.c @@ -0,0 +1,23 @@ +// RUN: clang-cc %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}} + + +// rdar://6881069 +__attribute__((vector_size(16))) // expected-error {{unsupported type 'float (void)' for vector_size attribute, please use on typedef}} +float f1(void) { +} diff --git a/test/Sema/vla.c b/test/Sema/vla.c new file mode 100644 index 0000000..70ba08b --- /dev/null +++ b/test/Sema/vla.c @@ -0,0 +1,56 @@ +// RUN: clang-cc %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 {{size of static array must be an integer constant expression}} + +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-error {{variable-sized object may not be initialized}} diff --git a/test/Sema/void_arg.c b/test/Sema/void_arg.c new file mode 100644 index 0000000..6799146 --- /dev/null +++ b/test/Sema/void_arg.c @@ -0,0 +1,26 @@ +/* RUN: clang-cc -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/test/Sema/warn-freestanding-complex.c b/test/Sema/warn-freestanding-complex.c new file mode 100644 index 0000000..a4d3f5b --- /dev/null +++ b/test/Sema/warn-freestanding-complex.c @@ -0,0 +1,4 @@ +// RUN: clang-cc -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/test/Sema/warn-missing-prototypes.c b/test/Sema/warn-missing-prototypes.c new file mode 100644 index 0000000..299d8a7 --- /dev/null +++ b/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/test/Sema/wchar.c b/test/Sema/wchar.c new file mode 100644 index 0000000..1637600 --- /dev/null +++ b/test/Sema/wchar.c @@ -0,0 +1,12 @@ +// RUN: clang-cc %s -fsyntax-only -verify +#include <wchar.h> + +int check_wchar_size[sizeof(*L"") == sizeof(wchar_t) ? 1 : -1]; + +void foo() { + int t1[] = L"x"; + wchar_t tab[] = L"x"; + + int t2[] = "x"; // expected-error {{initialization}} + char t3[] = L"x"; // expected-error {{initialization}} +} |
