diff options
Diffstat (limited to 'test/Sema')
43 files changed, 425 insertions, 126 deletions
diff --git a/test/Sema/address_spaces.c b/test/Sema/address_spaces.c index 6258114..23c1405 100644 --- a/test/Sema/address_spaces.c +++ b/test/Sema/address_spaces.c @@ -36,7 +36,7 @@ struct _st { // 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}} \ + return base[0]; // expected-error {{illegal implicit conversion between two pointers with different address spaces}} \ expected-warning {{returning 'void __attribute__((address_space(256))) *' from a function with result type 'void *' discards qualifiers}} } diff --git a/test/Sema/align-x86-64.c b/test/Sema/align-x86-64.c new file mode 100644 index 0000000..6dcf571 --- /dev/null +++ b/test/Sema/align-x86-64.c @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fsyntax-only -verify %s + +// PR5599 + +void frob(void *); + +void foo(void) { + float x[4]; + char y[__alignof__(x) == 16 ? 1 : -1]; + frob(y); +} diff --git a/test/Sema/attr-deprecated.c b/test/Sema/attr-deprecated.c index e723255..e7c997f 100644 --- a/test/Sema/attr-deprecated.c +++ b/test/Sema/attr-deprecated.c @@ -4,8 +4,6 @@ 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() { @@ -45,7 +43,7 @@ typedef struct foo foo_dep __attribute__((deprecated)); foo_dep *test2; // expected-warning {{'foo_dep' is deprecated}} struct bar_dep __attribute__((deprecated, - invalid_attribute)); // expected-warning {{'invalid_attribute' attribute ignored}} + invalid_attribute)); // expected-warning {{unknown attribute 'invalid_attribute' ignored}} struct bar_dep *test3; // expected-warning {{'bar_dep' is deprecated}} diff --git a/test/Sema/attr-regparm.c b/test/Sema/attr-regparm.c index 045a413..4049e0e 100644 --- a/test/Sema/attr-regparm.c +++ b/test/Sema/attr-regparm.c @@ -1,7 +1,11 @@ // RUN: %clang_cc1 -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)}} +__attribute((regparm(2))) int x0(void); +__attribute((regparm(1.0))) int x1(void); // expected-error{{'regparm' attribute requires integer constant}} +__attribute((regparm(-1))) int x2(void); // expected-error{{'regparm' parameter must be between 0 and 3 inclusive}} +__attribute((regparm(5))) int x3(void); // expected-error{{'regparm' parameter must be between 0 and 3 inclusive}} +__attribute((regparm(5,3))) int x4(void); // expected-error{{attribute requires 1 argument(s)}} + +void __attribute__((regparm(3))) x5(int); +void x5(int); // expected-note{{previous declaration is here}} +void __attribute__((regparm(2))) x5(int); // expected-error{{function declared with with regparm(2) attribute was previously declared with the regparm(3) attribute}} diff --git a/test/Sema/attr-unknown.c b/test/Sema/attr-unknown.c new file mode 100644 index 0000000..bec2e29 --- /dev/null +++ b/test/Sema/attr-unknown.c @@ -0,0 +1,4 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wunknown-attributes %s + +int x __attribute__((foobar)); // expected-warning {{unknown attribute 'foobar' ignored}} +void z() __attribute__((bogusattr)); // expected-warning {{unknown attribute 'bogusattr' ignored}} diff --git a/test/Sema/bitfield-layout.c b/test/Sema/bitfield-layout.c index edc44bd..2655fc7 100644 --- a/test/Sema/bitfield-layout.c +++ b/test/Sema/bitfield-layout.c @@ -30,3 +30,13 @@ CHECK_ALIGN(struct, e, 1) struct f {__attribute((aligned(8))) int x : 30, y : 30, z : 30;}; CHECK_SIZE(struct, f, 24) CHECK_ALIGN(struct, f, 8) + +// Large structure (overflows i32, in bits). +struct s0 { + char a[0x32100000]; + int x:30, y:30; +}; + +CHECK_SIZE(struct, s0, 0x32100008) +CHECK_ALIGN(struct, s0, 4) + diff --git a/test/Sema/block-call.c b/test/Sema/block-call.c index 318bc6b..28e6c68 100644 --- a/test/Sema/block-call.c +++ b/test/Sema/block-call.c @@ -13,9 +13,11 @@ int main() { int (^IFP) () = PFR; // OK - const int (^CIC) () = IFP; // expected-error {{incompatible block pointer types initializing 'int const (^)()' with an expression of type 'int (^)()'}} + const int (^CIC) () = IFP; // expected-error {{incompatible block pointer types initializing 'int const (^)()' with an expression of type 'int (^)()'}} \ + // expected-warning{{type qualifier on return type has no effect}} + + const int (^CICC) () = CIC; // expected-warning{{type qualifier on return type has no effect}} - const int (^CICC) () = CIC; int * const (^IPCC) () = 0; diff --git a/test/Sema/block-return.c b/test/Sema/block-return.c index 10b3b84..33fd183 100644 --- a/test/Sema/block-return.c +++ b/test/Sema/block-return.c @@ -109,8 +109,11 @@ void foo6() { void foo7() { - const int (^BB) (void) = ^{ const int i = 1; return i; }; // expected-error{{incompatible block pointer types initializing 'int const (^)(void)' with an expression of type 'int (^)(void)'}} - const int (^CC) (void) = ^const int{ const int i = 1; return i; }; // OK + const int (^BB) (void) = ^{ const int i = 1; return i; }; // expected-error{{incompatible block pointer types initializing 'int const (^)(void)' with an expression of type 'int (^)(void)'}} \ + // expected-warning{{type qualifier on return type has no effect}} + + const int (^CC) (void) = ^const int{ const int i = 1; return i; }; // expected-warning{{type qualifier on return type has no effect}} + int i; int (^FF) (void) = ^{ return i; }; // OK diff --git a/test/Sema/builtins.c b/test/Sema/builtins.c index 6fa563b..c0a2131 100644 --- a/test/Sema/builtins.c +++ b/test/Sema/builtins.c @@ -40,7 +40,10 @@ void test9(short v) { 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}} + old = __sync_fetch_and_add((unsigned*)0, 42i); // expected-warning {{imaginary constants are an extension}} + + // PR7600: Pointers are implicitly casted to integers and back. + void *old_ptr = __sync_val_compare_and_swap((void**)0, 0, 0); } diff --git a/test/Sema/compare.c b/test/Sema/compare.c index f997dc1..b2c3563 100644 --- a/test/Sema/compare.c +++ b/test/Sema/compare.c @@ -3,7 +3,7 @@ int test(char *C) { // nothing here should warn. return C != ((void*)0); return C != (void*)0; - return C != 0; + return C != 0; return C != 1; // expected-warning {{comparison between pointer and integer ('char *' and 'int')}} } @@ -218,7 +218,7 @@ int pointers(int *a) { int function_pointers(int (*a)(int), int (*b)(int), void (*c)(int)) { return a > b; // expected-warning {{ordered comparison of function pointers}} - return function_pointers > function_pointers; // expected-warning {{ordered comparison of function pointers}} + return function_pointers > function_pointers; // expected-warning {{self-comparison always evaluates to false}} expected-warning{{ordered comparison of function pointers}} return a > c; // expected-warning {{comparison of distinct pointer types}} return a == (void *) 0; return a == (void *) 1; // expected-warning {{equality comparison between function pointer and void pointer}} @@ -229,6 +229,7 @@ int void_pointers(void* foo) { return foo == (void*) 1; } + int test1(int i) { enum en { zero }; return i > zero; diff --git a/test/Sema/const-eval.c b/test/Sema/const-eval.c index 9c53725..c132b34 100644 --- a/test/Sema/const-eval.c +++ b/test/Sema/const-eval.c @@ -74,5 +74,5 @@ const _Bool constbool = 0; EVAL_EXPR(35, constbool) EVAL_EXPR(36, constbool) -EVAL_EXPR(37, (1,2.0) == 2.0) +EVAL_EXPR(37, (1,2.0) == 2.0) // expected-warning {{expression result unused}} EVAL_EXPR(38, __builtin_expect(1,1) == 1) diff --git a/test/Sema/conversion-64-32.c b/test/Sema/conversion-64-32.c index 1043996..aa72829 100644 --- a/test/Sema/conversion-64-32.c +++ b/test/Sema/conversion-64-32.c @@ -1,5 +1,5 @@ // RUN: %clang_cc1 -fsyntax-only -verify -Wshorten-64-to-32 -triple x86_64-apple-darwin %s int test0(long v) { - return v; // expected-warning {{implicit cast loses integer precision}} + return v; // expected-warning {{implicit conversion loses integer precision}} } diff --git a/test/Sema/conversion.c b/test/Sema/conversion.c index 5b09ec6..5fbd64d 100644 --- a/test/Sema/conversion.c +++ b/test/Sema/conversion.c @@ -6,17 +6,17 @@ void test0(char c, short s, int i, long l, long long ll) { c = c; - c = s; // expected-warning {{implicit cast loses integer precision}} - c = i; // expected-warning {{implicit cast loses integer precision}} - c = l; // expected-warning {{implicit cast loses integer precision}} + c = s; // expected-warning {{implicit conversion loses integer precision}} + c = i; // expected-warning {{implicit conversion loses integer precision}} + c = l; // expected-warning {{implicit conversion loses integer precision}} s = c; s = s; - s = i; // expected-warning {{implicit cast loses integer precision}} - s = l; // expected-warning {{implicit cast loses integer precision}} + s = i; // expected-warning {{implicit conversion loses integer precision}} + s = l; // expected-warning {{implicit conversion loses integer precision}} i = c; i = s; i = i; - i = l; // expected-warning {{implicit cast loses integer precision}} + i = l; // expected-warning {{implicit conversion loses integer precision}} l = c; l = s; l = i; @@ -40,17 +40,17 @@ void test0(char c, short s, int i, long l, long long ll) { l = (long) 0; c = (char) BIG; - c = (short) BIG; // expected-warning {{implicit cast loses integer precision}} - c = (int) BIG; // expected-warning {{implicit cast loses integer precision}} - c = (long) BIG; // expected-warning {{implicit cast loses integer precision}} + c = (short) BIG; // expected-warning {{implicit conversion loses integer precision}} + c = (int) BIG; // expected-warning {{implicit conversion loses integer precision}} + c = (long) BIG; // expected-warning {{implicit conversion loses integer precision}} s = (char) BIG; s = (short) BIG; - s = (int) BIG; // expected-warning {{implicit cast loses integer precision}} - s = (long) BIG; // expected-warning {{implicit cast loses integer precision}} + s = (int) BIG; // expected-warning {{implicit conversion loses integer precision}} + s = (long) BIG; // expected-warning {{implicit conversion loses integer precision}} i = (char) BIG; i = (short) BIG; i = (int) BIG; - i = (long) BIG; // expected-warning {{implicit cast loses integer precision}} + i = (long) BIG; // expected-warning {{implicit conversion loses integer precision}} l = (char) BIG; l = (short) BIG; l = (int) BIG; @@ -58,39 +58,39 @@ void test0(char c, short s, int i, long l, long long ll) { } char test1(long long ll) { - return (long long) ll; // expected-warning {{implicit cast loses integer precision}} - return (long) ll; // expected-warning {{implicit cast loses integer precision}} - return (int) ll; // expected-warning {{implicit cast loses integer precision}} - return (short) ll; // expected-warning {{implicit cast loses integer precision}} + return (long long) ll; // expected-warning {{implicit conversion loses integer precision}} + return (long) ll; // expected-warning {{implicit conversion loses integer precision}} + return (int) ll; // expected-warning {{implicit conversion loses integer precision}} + return (short) ll; // expected-warning {{implicit conversion loses integer precision}} return (char) ll; - return (long long) BIG; // expected-warning {{implicit cast loses integer precision}} - return (long) BIG; // expected-warning {{implicit cast loses integer precision}} - return (int) BIG; // expected-warning {{implicit cast loses integer precision}} - return (short) BIG; // expected-warning {{implicit cast loses integer precision}} + return (long long) BIG; // expected-warning {{implicit conversion loses integer precision}} + return (long) BIG; // expected-warning {{implicit conversion loses integer precision}} + return (int) BIG; // expected-warning {{implicit conversion loses integer precision}} + return (short) BIG; // expected-warning {{implicit conversion loses integer precision}} return (char) BIG; } short test2(long long ll) { - return (long long) ll; // expected-warning {{implicit cast loses integer precision}} - return (long) ll; // expected-warning {{implicit cast loses integer precision}} - return (int) ll; // expected-warning {{implicit cast loses integer precision}} + return (long long) ll; // expected-warning {{implicit conversion loses integer precision}} + return (long) ll; // expected-warning {{implicit conversion loses integer precision}} + return (int) ll; // expected-warning {{implicit conversion loses integer precision}} return (short) ll; return (char) ll; - return (long long) BIG; // expected-warning {{implicit cast loses integer precision}} - return (long) BIG; // expected-warning {{implicit cast loses integer precision}} - return (int) BIG; // expected-warning {{implicit cast loses integer precision}} + return (long long) BIG; // expected-warning {{implicit conversion loses integer precision}} + return (long) BIG; // expected-warning {{implicit conversion loses integer precision}} + return (int) BIG; // expected-warning {{implicit conversion loses integer precision}} return (short) BIG; return (char) BIG; } int test3(long long ll) { - return (long long) ll; // expected-warning {{implicit cast loses integer precision}} - return (long) ll; // expected-warning {{implicit cast loses integer precision}} + return (long long) ll; // expected-warning {{implicit conversion loses integer precision}} + return (long) ll; // expected-warning {{implicit conversion loses integer precision}} return (int) ll; return (short) ll; return (char) ll; - return (long long) BIG; // expected-warning {{implicit cast loses integer precision}} - return (long) BIG; // expected-warning {{implicit cast loses integer precision}} + return (long long) BIG; // expected-warning {{implicit conversion loses integer precision}} + return (long) BIG; // expected-warning {{implicit conversion loses integer precision}} return (int) BIG; return (short) BIG; return (char) BIG; @@ -143,7 +143,7 @@ void test6(char v) { } void test7(short v) { - takes_char(v); // expected-warning {{implicit cast loses integer precision}} + takes_char(v); // expected-warning {{implicit conversion loses integer precision}} takes_short(v); takes_int(v); takes_long(v); @@ -154,8 +154,8 @@ void test7(short v) { } void test8(int v) { - takes_char(v); // expected-warning {{implicit cast loses integer precision}} - takes_short(v); // expected-warning {{implicit cast loses integer precision}} + takes_char(v); // expected-warning {{implicit conversion loses integer precision}} + takes_short(v); // expected-warning {{implicit conversion loses integer precision}} takes_int(v); takes_long(v); takes_longlong(v); @@ -165,9 +165,9 @@ void test8(int v) { } void test9(long v) { - takes_char(v); // expected-warning {{implicit cast loses integer precision}} - takes_short(v); // expected-warning {{implicit cast loses integer precision}} - takes_int(v); // expected-warning {{implicit cast loses integer precision}} + takes_char(v); // expected-warning {{implicit conversion loses integer precision}} + takes_short(v); // expected-warning {{implicit conversion loses integer precision}} + takes_int(v); // expected-warning {{implicit conversion loses integer precision}} takes_long(v); takes_longlong(v); takes_float(v); @@ -176,9 +176,9 @@ void test9(long v) { } void test10(long long v) { - takes_char(v); // expected-warning {{implicit cast loses integer precision}} - takes_short(v); // expected-warning {{implicit cast loses integer precision}} - takes_int(v); // expected-warning {{implicit cast loses integer precision}} + takes_char(v); // expected-warning {{implicit conversion loses integer precision}} + takes_short(v); // expected-warning {{implicit conversion loses integer precision}} + takes_int(v); // expected-warning {{implicit conversion loses integer precision}} takes_long(v); takes_longlong(v); takes_float(v); @@ -187,35 +187,35 @@ void test10(long long v) { } void test11(float v) { - takes_char(v); // expected-warning {{implicit cast turns floating-point number into integer}} - takes_short(v); // expected-warning {{implicit cast turns floating-point number into integer}} - takes_int(v); // expected-warning {{implicit cast turns floating-point number into integer}} - takes_long(v); // expected-warning {{implicit cast turns floating-point number into integer}} - takes_longlong(v); // expected-warning {{implicit cast turns floating-point number into integer}} + takes_char(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_short(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_int(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_long(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_longlong(v); // expected-warning {{implicit conversion turns floating-point number into integer}} takes_float(v); takes_double(v); takes_longdouble(v); } void test12(double v) { - takes_char(v); // expected-warning {{implicit cast turns floating-point number into integer}} - takes_short(v); // expected-warning {{implicit cast turns floating-point number into integer}} - takes_int(v); // expected-warning {{implicit cast turns floating-point number into integer}} - takes_long(v); // expected-warning {{implicit cast turns floating-point number into integer}} - takes_longlong(v); // expected-warning {{implicit cast turns floating-point number into integer}} - takes_float(v); // expected-warning {{implicit cast loses floating-point precision}} + takes_char(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_short(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_int(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_long(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_longlong(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_float(v); // expected-warning {{implicit conversion loses floating-point precision}} takes_double(v); takes_longdouble(v); } void test13(long double v) { - takes_char(v); // expected-warning {{implicit cast turns floating-point number into integer}} - takes_short(v); // expected-warning {{implicit cast turns floating-point number into integer}} - takes_int(v); // expected-warning {{implicit cast turns floating-point number into integer}} - takes_long(v); // expected-warning {{implicit cast turns floating-point number into integer}} - takes_longlong(v); // expected-warning {{implicit cast turns floating-point number into integer}} - takes_float(v); // expected-warning {{implicit cast loses floating-point precision}} - takes_double(v); // expected-warning {{implicit cast loses floating-point precision}} + takes_char(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_short(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_int(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_long(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_longlong(v); // expected-warning {{implicit conversion turns floating-point number into integer}} + takes_float(v); // expected-warning {{implicit conversion loses floating-point precision}} + takes_double(v); // expected-warning {{implicit conversion loses floating-point precision}} takes_longdouble(v); } @@ -229,13 +229,13 @@ void test14(long l) { void test15(char c) { c = c + 1 + c * 2; - c = (short) c + 1 + c * 2; // expected-warning {{implicit cast loses integer precision}} + c = (short) c + 1 + c * 2; // expected-warning {{implicit conversion loses integer precision}} } // PR 5422 extern void *test16_external; void test16(void) { - int a = (unsigned long) &test16_external; // expected-warning {{implicit cast loses integer precision}} + int a = (unsigned long) &test16_external; // expected-warning {{implicit conversion loses integer precision}} } // PR 5938 @@ -249,7 +249,7 @@ void test17() { unsigned int x; x = U.a; x = U.b; - x = U.c; // expected-warning {{implicit cast loses integer precision}} + x = U.c; // expected-warning {{implicit conversion loses integer precision}} } // PR 5939 @@ -277,7 +277,7 @@ unsigned char test19(unsigned long u64) { // <rdar://problem/7631400> void test_7631400(void) { // This should show up despite the caret being inside a macro substitution - char s = LONG_MAX; // expected-warning {{implicit cast loses integer precision: 'long' to 'char'}} + char s = LONG_MAX; // expected-warning {{implicit conversion loses integer precision: 'long' to 'char'}} } // <rdar://problem/7676608>: assertion for compound operators with non-integral RHS @@ -291,9 +291,9 @@ void test_7676608(void) { // <rdar://problem/7904686> void test_7904686(void) { const int i = -1; - unsigned u1 = i; // expected-warning {{implicit cast changes signedness}} - u1 = i; // expected-warning {{implicit cast changes signedness}} + unsigned u1 = i; // expected-warning {{implicit conversion changes signedness}} + u1 = i; // expected-warning {{implicit conversion changes signedness}} - unsigned u2 = -1; // expected-warning {{implicit cast changes signedness}} - u2 = -1; // expected-warning {{implicit cast changes signedness}} + unsigned u2 = -1; // expected-warning {{implicit conversion changes signedness}} + u2 = -1; // expected-warning {{implicit conversion changes signedness}} } diff --git a/test/Sema/enum-packed.c b/test/Sema/enum-packed.c new file mode 100644 index 0000000..0eb6c14 --- /dev/null +++ b/test/Sema/enum-packed.c @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// PR7477 +enum __attribute__((packed)) E { + Ea, Eb, Ec, Ed +}; + +void test_E(enum E e) { + switch (e) { + case Ea: + case Eb: + case Ec: + case Ed: + break; + } +} diff --git a/test/Sema/enum.c b/test/Sema/enum.c index ba4e56b..0570150 100644 --- a/test/Sema/enum.c +++ b/test/Sema/enum.c @@ -51,7 +51,7 @@ void test4() { } // PR2416 -enum someenum {}; // expected-warning {{use of empty enum extension}} +enum someenum {}; // expected-error {{use of empty enum}} // <rdar://problem/6093889> enum e0 { // expected-note {{previous definition is here}} diff --git a/test/Sema/expr-comma-c89.c b/test/Sema/expr-comma-c89.c index d0883ba..dc42702 100644 --- a/test/Sema/expr-comma-c89.c +++ b/test/Sema/expr-comma-c89.c @@ -11,7 +11,7 @@ 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]; +int X[sizeof(0, (foo().c)) == sizeof(char*) ? 1 : -1]; // expected-warning {{expression result unused}} +int Y[sizeof(0, (a,b).c) == sizeof(char*) ? 1 : -1]; // expected-warning {{expression result unused}} expected-warning {{expression result unused}} +int Z[sizeof(0, (a=b).c) == sizeof(char*) ? 1 : -1]; // expected-warning {{expression result unused}} diff --git a/test/Sema/expr-comma.c b/test/Sema/expr-comma.c index d3e4020..b004fc1 100644 --- a/test/Sema/expr-comma.c +++ b/test/Sema/expr-comma.c @@ -11,7 +11,7 @@ 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]; +int W[sizeof(0, a.c) == sizeof(char*) ? 1 : -1]; // expected-warning {{expression result unused}} +int X[sizeof(0, (foo().c)) == 17 ? 1 : -1]; // expected-warning {{expression result unused}} +int Y[sizeof(0, (a,b).c) == 17 ? 1 : -1]; // expected-warning {{expression result unused}} // expected-warning {{expression result unused}} +int Z[sizeof(0, (a=b).c) == 17 ? 1 : -1]; // expected-warning {{expression result unused}} diff --git a/test/Sema/exprs.c b/test/Sema/exprs.c index dbb6e80..b22b522 100644 --- a/test/Sema/exprs.c +++ b/test/Sema/exprs.c @@ -134,3 +134,11 @@ void test18(int b) { test18_a(b, b); // expected-error {{too many arguments to function call, expected 1, have 2}} test18_a(); // expected-error {{too few arguments to function call, expected 1, have 0}} } + +// PR7569 +void test19() { + *(int*)0 = 0; // expected-warning {{indirection of non-volatile null pointer}} \ + // expected-note {{consider using __builtin_trap}} + *(volatile int*)0 = 0; // Ok. +} + diff --git a/test/Sema/ext_vector_casts.c b/test/Sema/ext_vector_casts.c index d297623..7681953 100644 --- a/test/Sema/ext_vector_casts.c +++ b/test/Sema/ext_vector_casts.c @@ -43,3 +43,10 @@ static void test() { ivec4 |= ivec4; ivec4 += ptr; // expected-error {{can't convert between vector values of different size ('int4' and 'int *')}} } + +typedef __attribute__(( ext_vector_type(2) )) float2 vecfloat2; // expected-error{{invalid vector element type 'float2'}} + +void inc(float2 f2) { + f2++; // expected-error{{cannot increment value of type 'float2'}} + __real f2; // expected-error{{invalid type 'float2' to __real operator}} +} diff --git a/test/Sema/ext_vector_comparisons.c b/test/Sema/ext_vector_comparisons.c new file mode 100644 index 0000000..605ba6c --- /dev/null +++ b/test/Sema/ext_vector_comparisons.c @@ -0,0 +1,30 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wno-unreachable-code %s + +typedef __attribute__(( ext_vector_type(4) )) int int4; + +static int4 test1() { + int4 vec, rv; + + // comparisons to self... + return vec == vec; // expected-warning{{self-comparison always evaluates to a constant}} + return vec != vec; // expected-warning{{self-comparison always evaluates to a constant}} + return vec < vec; // expected-warning{{self-comparison always evaluates to a constant}} + return vec <= vec; // expected-warning{{self-comparison always evaluates to a constant}} + return vec > vec; // expected-warning{{self-comparison always evaluates to a constant}} + return vec >= vec; // expected-warning{{self-comparison always evaluates to a constant}} +} + + +typedef __attribute__(( ext_vector_type(4) )) float float4; + +static int4 test2() { + float4 vec, rv; + + // comparisons to self. no warning, they're floats + return vec == vec; // no-warning + return vec != vec; // no-warning + return vec < vec; // no-warning + return vec <= vec; // no-warning + return vec > vec; // no-warning + return vec >= vec; // no-warning +} diff --git a/test/Sema/extern-redecl.c b/test/Sema/extern-redecl.c new file mode 100644 index 0000000..067e3c2 --- /dev/null +++ b/test/Sema/extern-redecl.c @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 -fsyntax-only %s + +// rdar: // 8125274 +static int a16[]; // expected-warning {{tentative array definition assumed to have one element}} + +void f16(void) { + extern int a16[]; +} + diff --git a/test/Sema/format-strings-fixit.c b/test/Sema/format-strings-fixit.c new file mode 100644 index 0000000..7cd76c7 --- /dev/null +++ b/test/Sema/format-strings-fixit.c @@ -0,0 +1,44 @@ +// RUN: cp %s %t +// RUN: %clang_cc1 -pedantic -Wall -fixit %t || true +// RUN: %clang_cc1 -fsyntax-only -pedantic -Wall -Werror %t + +/* This is a test of the various code modification hints that are + provided as part of warning or extension diagnostics. All of the + warnings will be fixed by -fixit, and the resulting file should + compile cleanly with -Werror -pedantic. */ + +int printf(char const *, ...); + +void test() { + // Basic types + printf("%s", (int) 123); + printf("abc%0f", "testing testing 123"); + printf("%u", (long) -12); + printf("%p", 123); + printf("%c\n", "x"); + printf("%c\n", 1.23); + + // Larger types + printf("%+.2d", (unsigned long long) 123456); + printf("%1d", (long double) 1.23); + + // Flag handling + printf("%0+s", (unsigned) 31337); // 0 flag should stay + printf("%#p", (void *) 0); + printf("% +f", 1.23); // + flag should stay + printf("%0-f", 1.23); // - flag should stay + + // Positional arguments + printf("%1$f:%2$.*3$f:%4$.*3$f\n", 1, 2, 3, 4); + + // Precision + printf("%10.5d", 1l); // (bug 7394) + printf("%.2c", 'a'); + + // Ignored flags + printf("%0-f", 1.23); + + // Bad length modifiers + printf("%hhs", "foo"); + printf("%1$zp", (void *)0); +} diff --git a/test/Sema/format-strings.c b/test/Sema/format-strings.c index d6d3796..c6dee68 100644 --- a/test/Sema/format-strings.c +++ b/test/Sema/format-strings.c @@ -172,18 +172,21 @@ void test10(int x, float f, int i, long long lli) { printf("%f\n", (long double) 1.0); // expected-warning{{conversion specifies type 'double' but the argument has type 'long double'}} // The man page says that a zero precision is okay. printf("%.0Lf", (long double) 1.0); // no-warning + printf("%c\n", "x"); // expected-warning{{conversion specifies type 'int' but the argument has type 'char *'}} + printf("%c\n", 1.23); // expected-warning{{conversion specifies type 'int' but the argument has type 'double'}} } void test11(void *p, char *s) { printf("%p", p); // no-warning - printf("%.4p", p); // expected-warning{{precision used in 'p' conversion specifier (where it has no meaning)}} - printf("%+p", p); // expected-warning{{flag '+' results in undefined behavior in 'p' conversion specifier}} - printf("% p", p); // expected-warning{{flag ' ' results in undefined behavior in 'p' conversion specifier}} - printf("%0p", p); // expected-warning{{flag '0' results in undefined behavior in 'p' conversion specifier}} + printf("%p", 123); // expected-warning{{conversion specifies type 'void *' but the argument has type 'int'}} + printf("%.4p", p); // expected-warning{{precision used with 'p' conversion specifier, resulting in undefined behavior}} + printf("%+p", p); // expected-warning{{flag '+' results in undefined behavior with 'p' conversion specifier}} + printf("% p", p); // expected-warning{{flag ' ' results in undefined behavior with 'p' conversion specifier}} + printf("%0p", p); // expected-warning{{flag '0' results in undefined behavior with 'p' conversion specifier}} printf("%s", s); // no-warning - printf("%+s", p); // expected-warning{{flag '+' results in undefined behavior in 's' conversion specifier}} - printf("% s", p); // expected-warning{{flag ' ' results in undefined behavior in 's' conversion specifier}} - printf("%0s", p); // expected-warning{{flag '0' results in undefined behavior in 's' conversion specifier}} + printf("%+s", p); // expected-warning{{flag '+' results in undefined behavior with 's' conversion specifier}} + printf("% s", p); // expected-warning{{flag ' ' results in undefined behavior with 's' conversion specifier}} + printf("%0s", p); // expected-warning{{flag '0' results in undefined behavior with 's' conversion specifier}} } void test12(char *b) { @@ -254,3 +257,30 @@ void test_pr_6697() { void rdar8026030(FILE *fp) { fprintf(fp, "\%"); // expected-warning{{incomplete format specifier}} } + +void bug7377_bad_length_mod_usage() { + // Bad length modifiers + printf("%hhs", "foo"); // expected-warning{{length modifier 'hh' results in undefined behavior or no effect with 's' conversion specifier}} + printf("%1$zp", (void *)0); // expected-warning{{length modifier 'z' results in undefined behavior or no effect with 'p' conversion specifier}} + printf("%ls", L"foo"); // no-warning + printf("%#.2Lf", (long double)1.234); // no-warning + + // Bad flag usage + printf("%#p", (void *) 0); // expected-warning{{flag '#' results in undefined behavior with 'p' conversion specifier}} + printf("%0d", -1); // no-warning + printf("%#n", (void *) 0); // expected-warning{{flag '#' results in undefined behavior with 'n' conversion specifier}} expected-warning{{use of '%n' in format string discouraged (potentially insecure)}} + printf("%-n", (void *) 0); // expected-warning{{flag '-' results in undefined behavior with 'n' conversion specifier}} expected-warning{{use of '%n' in format string discouraged (potentially insecure)}} + printf("%-p", (void *) 0); // no-warning + + // Bad optional amount use + printf("%.2c", 'a'); // expected-warning{{precision used with 'c' conversion specifier, resulting in undefined behavior}} + printf("%1n", (void *) 0); // expected-warning{{field width used with 'n' conversion specifier, resulting in undefined behavior}} expected-warning{{use of '%n' in format string discouraged (potentially insecure)}} + printf("%.9n", (void *) 0); // expected-warning{{precision used with 'n' conversion specifier, resulting in undefined behavior}} expected-warning{{use of '%n' in format string discouraged (potentially insecure)}} + + // Ignored flags + printf("% +f", 1.23); // expected-warning{{flag ' ' is ignored when flag '+' is present}} + printf("%+ f", 1.23); // expected-warning{{flag ' ' is ignored when flag '+' is present}} + printf("%0-f", 1.23); // expected-warning{{flag '0' is ignored when flag '-' is present}} + printf("%-0f", 1.23); // expected-warning{{flag '0' is ignored when flag '-' is present}} + printf("%-+f", 1.23); // no-warning +} diff --git a/test/Sema/function-redecl.c b/test/Sema/function-redecl.c index 633ad21..27ec163 100644 --- a/test/Sema/function-redecl.c +++ b/test/Sema/function-redecl.c @@ -126,6 +126,6 @@ void test_x() { x2(5); // expected-warning{{incompatible integer to pointer conversion passing 'int' to parameter of type 'int *'}} } -enum e0 {}; +enum e0 {one}; void f3(); void f3(enum e0 x) {} diff --git a/test/Sema/function.c b/test/Sema/function.c index 9a83519..b51c137 100644 --- a/test/Sema/function.c +++ b/test/Sema/function.c @@ -34,10 +34,10 @@ void t12(int) {} // expected-error{{parameter name omitted}} // PR2790 void t13() { - return 0; // expected-warning {{void function 't13' should not return a value}} + return 0; // expected-error {{void function 't13' should not return a value}} } int t14() { - return; // expected-warning {{non-void function 't14' should return a value}} + return; // expected-error {{non-void function 't14' should return a value}} } // <rdar://problem/6097326> diff --git a/test/Sema/i-c-e.c b/test/Sema/i-c-e.c index 97d9f43..c86a93f 100644 --- a/test/Sema/i-c-e.c +++ b/test/Sema/i-c-e.c @@ -50,9 +50,10 @@ 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}} +int comma1[0?1,2:3]; // expected-warning {{expression result unused}} +int comma2[1||(1,2)]; // expected-warning {{expression result unused}} +int comma3[(1,2)]; // expected-warning {{size of static array must be an integer constant expression}} \ + // expected-warning {{expression result unused}} // 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}} diff --git a/test/Sema/implicit-decl.c b/test/Sema/implicit-decl.c index 830cde9..f455977 100644 --- a/test/Sema/implicit-decl.c +++ b/test/Sema/implicit-decl.c @@ -10,7 +10,6 @@ void func() { if (_CFCalendarDecomposeAbsoluteTimeV(compDesc, vector, compCount)) { // expected-note {{previous implicit declaration is here}} \ expected-warning {{implicit declaration of function '_CFCalendarDecomposeAbsoluteTimeV' is invalid in C99}} } - 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/init.c b/test/Sema/init.c index c2c29ad..ac274a4ce 100644 --- a/test/Sema/init.c +++ b/test/Sema/init.c @@ -118,8 +118,6 @@ 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; diff --git a/test/Sema/missing-field-initializers.c b/test/Sema/missing-field-initializers.c index 8281914..6aa48ba 100644 --- a/test/Sema/missing-field-initializers.c +++ b/test/Sema/missing-field-initializers.c @@ -20,6 +20,8 @@ struct Foo bar1[] = { 1 }; // expected-warning {{missing field 'b' initializer}} +struct Foo bar2[] = { {}, {}, {} }; + struct One { int a; int b; }; struct Two { float c; float d; float e; }; diff --git a/test/Sema/opencl-init.c b/test/Sema/opencl-init.c new file mode 100644 index 0000000..3d116bd --- /dev/null +++ b/test/Sema/opencl-init.c @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 %s -x cl -verify -pedantic -fsyntax-only + +typedef float float8 __attribute((ext_vector_type(8))); + +typedef float float32_t; +typedef __attribute__(( __vector_size__(16) )) float32_t __neon_float32x4_t; +typedef struct __simd128_float32_t { + __neon_float32x4_t val; +} float32x4_t; + +float8 foo(float8 x) { + float32x4_t lo; + float32x4_t hi; + return (float8) (lo.val, hi.val); +} diff --git a/test/Sema/pragma-align-mac68k-unsupported.c b/test/Sema/pragma-align-mac68k-unsupported.c index 6588aa1..c23c01b 100644 --- a/test/Sema/pragma-align-mac68k-unsupported.c +++ b/test/Sema/pragma-align-mac68k-unsupported.c @@ -1,4 +1,4 @@ -// RUN: %clang-cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify %s -// RUN: %clang-cc1 -triple i386-pc-linux-gnu -fsyntax-only -verify %s +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify %s +// RUN: %clang_cc1 -triple i386-pc-linux-gnu -fsyntax-only -verify %s /* expected-error {{mac68k alignment pragma is not supported}} */ #pragma options align=mac68k diff --git a/test/Sema/pragma-align-mac68k.c b/test/Sema/pragma-align-mac68k.c index d13a0be..fb8da51 100644 --- a/test/Sema/pragma-align-mac68k.c +++ b/test/Sema/pragma-align-mac68k.c @@ -1,4 +1,4 @@ -// RUN: %clang-cc1 -triple i386-apple-darwin9 -fsyntax-only -verify %s +// RUN: %clang_cc1 -triple i386-apple-darwin9 -fsyntax-only -verify %s #include <stddef.h> diff --git a/test/Sema/pragma-align-packed.c b/test/Sema/pragma-align-packed.c new file mode 100644 index 0000000..30b87bf --- /dev/null +++ b/test/Sema/pragma-align-packed.c @@ -0,0 +1,23 @@ +// RUN: %clang_cc1 -triple i386-apple-darwin9 -fsyntax-only -verify %s + +#pragma pack(push, 1) +struct s0 { + char f0; + int f1 __attribute__((aligned(4))); +}; +extern int a[sizeof(struct s0) == 5 ? 1 : -1]; +#pragma pack(pop) + +struct __attribute__((packed)) s1 { + char f0; + int f1 __attribute__((aligned(4))); +}; +extern int a[sizeof(struct s1) == 8 ? 1 : -1]; + +#pragma options align=packed +struct s2 { + char f0; + int f1 __attribute__((aligned(4))); +}; +extern int a[sizeof(struct s2) == 5 ? 1 : -1]; +#pragma options align=reset diff --git a/test/Sema/pragma-pack-and-options-align.c b/test/Sema/pragma-pack-and-options-align.c index c880ed6..ebf1ade 100644 --- a/test/Sema/pragma-pack-and-options-align.c +++ b/test/Sema/pragma-pack-and-options-align.c @@ -16,6 +16,14 @@ struct s1 { }; extern int a[sizeof(struct s1) == 8 ? 1 : -1]; +#pragma options align=reset +#pragma options align=native +struct s1_1 { + char c; + int x; +}; +extern int a[sizeof(struct s1_1) == 8 ? 1 : -1]; + #pragma pack(pop) struct s2 { char c; diff --git a/test/Sema/return.c b/test/Sema/return.c index 0d46d98..2d23e08 100644 --- a/test/Sema/return.c +++ b/test/Sema/return.c @@ -1,4 +1,4 @@ -// RUN: %clang %s -fsyntax-only -Xclang -verify -fblocks -Wno-unreachable-code -Wno-unused-value +// RUN: %clang %s -fsyntax-only -Wreturn-type -Xclang -verify -fblocks -Wno-unreachable-code -Wno-unused-value // clang emits the following warning by default. // With GCC, -pedantic, -Wreturn-type or -Wall are required to produce the diff --git a/test/Sema/self-comparison.c b/test/Sema/self-comparison.c index 1baba27..c5c0611 100644 --- a/test/Sema/self-comparison.c +++ b/test/Sema/self-comparison.c @@ -1,11 +1,21 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s int foo(int x) { - return x == x; // expected-warning {{self-comparison always results}} + return x == x; // expected-warning {{self-comparison always evaluates to true}} } int foo2(int x) { - return (x) != (((x))); // expected-warning {{self-comparison always results}} + return (x) != (((x))); // expected-warning {{self-comparison always evaluates to false}} +} + +void foo3(short s, short t) { + if (s == s) {} // expected-warning {{self-comparison always evaluates to true}} + if (s == t) {} // no-warning +} + +void foo4(void* v, void* w) { + if (v == v) {} // expected-warning {{self-comparison always evaluates to true}} + if (v == w) {} // no-warning } int qux(int x) { @@ -24,15 +34,44 @@ 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 +#define IS_THE_ANSWER(x) (x == 42) + +int macro_comparison() { + return IS_THE_ANSWER(42); } // Don't complain in unevaluated contexts. int compare_sizeof(int x) { return sizeof(x == x); // no-warning } + +int array_comparisons() { + int array1[2]; + int array2[2]; + + // + // compare same array + // + return array1 == array1; // expected-warning{{self-comparison always evaluates to true}} + return array1 != array1; // expected-warning{{self-comparison always evaluates to false}} + return array1 < array1; // expected-warning{{self-comparison always evaluates to false}} + return array1 <= array1; // expected-warning{{self-comparison always evaluates to true}} + return array1 > array1; // expected-warning{{self-comparison always evaluates to false}} + return array1 >= array1; // expected-warning{{self-comparison always evaluates to true}} + + // + // compare differrent arrays + // + return array1 == array2; // expected-warning{{array comparison always evaluates to false}} + return array1 != array2; // expected-warning{{array comparison always evaluates to true}} + + // + // we don't know what these are going to be + // + return array1 < array2; // expected-warning{{array comparison always evaluates to a constant}} + return array1 <= array2; // expected-warning{{array comparison always evaluates to a constant}} + return array1 > array2; // expected-warning{{array comparison always evaluates to a constant}} + return array1 >= array2; // expected-warning{{array comparison always evaluates to a constant}} + +} + diff --git a/test/Sema/struct-cast.c b/test/Sema/struct-cast.c index dc7db13..3456665 100644 --- a/test/Sema/struct-cast.c +++ b/test/Sema/struct-cast.c @@ -5,7 +5,8 @@ struct S { int two; }; -struct S const foo(void); +struct S const foo(void); // expected-warning{{type qualifier on return type has no effect}} + struct S tmp; diff --git a/test/Sema/struct-decl.c b/test/Sema/struct-decl.c index f888053..3639d24 100644 --- a/test/Sema/struct-decl.c +++ b/test/Sema/struct-decl.c @@ -41,3 +41,8 @@ struct s0 { }; struct s0 f0(void) {} + +// <rdar://problem/8177927> - This previously triggered an assertion failure. +struct x0 { + unsigned int x1; +}; diff --git a/test/Sema/switch.c b/test/Sema/switch.c index 27ad066..bb48229 100644 --- a/test/Sema/switch.c +++ b/test/Sema/switch.c @@ -277,3 +277,14 @@ void test16() { case '6': return; } } + +// PR7359 +void test17(int x) { + switch (x >= 17) { // expected-warning {{switch condition has boolean value}} + case 0: return; + } + + switch ((int) (x <= 17)) { + case 0: return; + } +} diff --git a/test/Sema/transparent-union.c b/test/Sema/transparent-union.c index cdfc850..27d5c24 100644 --- a/test/Sema/transparent-union.c +++ b/test/Sema/transparent-union.c @@ -38,3 +38,10 @@ typedef union { } TU3 __attribute__((transparent_union)); typedef union { } TU4 __attribute__((transparent_union)); // expected-warning{{field}} + +typedef int int4 __attribute__((ext_vector_type(4))); +typedef union { + int4 vec; // expected-warning{{first field of a transparent union cannot have vector type 'int4'; transparent_union attribute ignored}} +} TU5 __attribute__((transparent_union)); + + diff --git a/test/Sema/types.c b/test/Sema/types.c index 1770bf5..f3244f7 100644 --- a/test/Sema/types.c +++ b/test/Sema/types.c @@ -36,4 +36,4 @@ _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}} +int __attribute__ ((vector_size (8), vector_size (8))) v; // expected-error {{invalid vector element type}} diff --git a/test/Sema/var-redecl.c b/test/Sema/var-redecl.c index 71d7ea1..f7576b6 100644 --- a/test/Sema/var-redecl.c +++ b/test/Sema/var-redecl.c @@ -58,5 +58,5 @@ int *p=&g19; // expected-error{{use of undeclared identifier 'g19'}} \ // PR3645 static int a; -extern int a; -int a; +extern int a; // expected-note {{previous definition is here}} +int a; // expected-error {{non-static declaration of 'a' follows static declaration}} diff --git a/test/Sema/warn-unused-value.c b/test/Sema/warn-unused-value.c index 16b787f..1a7e745 100644 --- a/test/Sema/warn-unused-value.c +++ b/test/Sema/warn-unused-value.c @@ -18,9 +18,9 @@ void pr4806() { i,foo(); // expected-warning {{expression result unused}} foo(),i; // expected-warning {{expression result unused}} - i,j,foo(); // expected-warning {{expression result unused}} - i,foo(),j; // expected-warning {{expression result unused}} - foo(),i,j; // expected-warning {{expression result unused}} + i,j,foo(); // expected-warning {{expression result unused}} expected-warning {{expression result unused}} + i,foo(),j; // expected-warning {{expression result unused}} expected-warning {{expression result unused}} + foo(),i,j; // expected-warning {{expression result unused}} expected-warning {{expression result unused}} i++; @@ -63,6 +63,16 @@ int test_logical_bar() { (x = test_logical_foo1()) || // no-warning (x = test_logical_foo2()) || // no-warning (x = test_logical_foo3()); // no-warning + + x || test_logical_foo1(); // no-warning + return x; } +struct s0 { int f0; }; + +void f0(int a); +void f1(struct s0 *a) { + // rdar://8139785 + f0((int)(a->f0 + 1, 10)); // expected-warning {{expression result unused}} +} |
