1 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only
3 // PR 8876 - don't warn about trivially unreachable null derefs. Note that
4 // we put this here because the reachability analysis only kicks in for
5 // suppressing false positives when code has no errors.
6 #define PR8876(err_ptr) do {\
7 if (err_ptr) *(int*)(err_ptr) = 1;\
10 #define PR8876_pos(err_ptr) do {\
11 if (!err_ptr) *(int*)(err_ptr) = 1;\
15 // Test that we don't report divide-by-zero errors in unreachable code.
16 // This test should be left as is, as it also tests CFG functionality.
19 0 / (0 ? 1 : 0); // expected-warning {{expression result unused}}
24 PR8876(0); // no-warning
25 PR8876_pos(0); // expected-warning{{indirection of non-volatile null pointer will be deleted, not trap}} expected-note{{consider using __builtin_trap() or qualifying pointer with 'volatile'}}
29 // PR 8183 - Handle null pointer constants on the left-side of the '&&', and reason about
30 // this when determining the reachability of the null pointer dereference on the right side.
31 void pr8183(unsigned long long test)
33 (void)((((void*)0)) && (*((unsigned long long*)(((void*)0))) = ((unsigned long long)((test)) % (unsigned long long)((1000000000))))); // no-warning
34 (*((unsigned long long*)(((void*)0))) = ((unsigned long long)((test)) % (unsigned long long)((1000000000)))); // expected-warning {{indirection of non-volatile null pointer will be deleted, not trap}} expected-note {{consider using __builtin_trap() or qualifying pointer with 'volatile'}}
38 _Complex double test1() {
39 return __extension__ 1.0if;
42 _Complex double test2() {
43 return 1.0if; // expected-warning {{imaginary constants are a GNU extension}}
49 (__extension__ x) = 10;
55 var =+ 5; // expected-warning {{use of unary operator that may be intended as compound assignment (+=)}}
56 var =- 5; // expected-warning {{use of unary operator that may be intended as compound assignment (-=)}}
57 var = +5; // no warning when space between the = and +.
60 var =+5; // no warning when the subexpr of the unary op has no space before it.
64 var=-FIVE; // no warning with macros.
69 void test5(int *X, float *P) {
70 (float*)X = P; // expected-error {{assignment to cast is illegal, lvalue casts are not supported}}
71 #define FOO ((float*) X)
72 FOO = P; // expected-error {{assignment to cast is illegal, lvalue casts are not supported}}
77 X(); // expected-error {{called object type 'int' is not a function or function pointer}}
80 void test7(int *P, _Complex float Gamma) {
81 P = (P-42) + Gamma*4; // expected-error {{invalid operands to binary expression ('int *' and '_Complex float')}}
88 __builtin_choose_expr (0, 42, i) = 10;
94 struct f { int x : 4; float y[]; };
95 int test9(struct f *P) {
97 R = __alignof(P->x); // expected-error {{invalid application of 'alignof' to bit-field}}
98 R = __alignof(P->y); // ok.
99 R = sizeof(P->x); // expected-error {{invalid application of 'sizeof' to bit-field}}
104 void test10(int n,...) {
106 double a[n]; // expected-error {{fields must have a constant size}}
108 double x = s.a[0]; // should not get another error here.
112 #define MYMAX(A,B) __extension__ ({ __typeof__(A) __a = (A); __typeof__(B) __b = (B); __a < __b ? __b : __a; })
114 struct mystruct {int A; };
115 void test11(struct mystruct P, float F) {
116 MYMAX(P, F); // expected-error {{invalid operands to binary expression ('typeof (P)' (aka 'struct mystruct') and 'typeof (F)' (aka 'float'))}}
120 int test12(const char *X) {
121 return X == "foo"; // expected-warning {{comparison against a string literal is unspecified (use strncmp instead)}}
124 int test12b(const char *X) {
125 return sizeof(X == "foo"); // no-warning
130 void (^P)()) { // expected-error {{blocks support disabled - compile with -fblocks}}
132 P = ^(){}; // expected-error {{blocks support disabled - compile with -fblocks}}
136 typedef long long __m64 __attribute__((__vector_size__(8)));
137 typedef short __v4hi __attribute__((__vector_size__(8)));
141 __m64 mask = (__m64)((__v4hi)a > (__v4hi)a);
146 typedef unsigned long *test15_t;
148 test15_t test15(void) {
149 return (test15_t)0 + (test15_t)0; // expected-error {{invalid operands to binary expression ('test15_t' (aka 'unsigned long *') and 'test15_t')}}
153 void test16(float x) { x == ((void*) 0); } // expected-error {{invalid operands to binary expression}}
157 x = x / 0; // expected-warning {{division by zero is undefined}}
158 x = x % 0; // expected-warning {{remainder by zero is undefined}}
159 x /= 0; // expected-warning {{division by zero is undefined}}
160 x %= 0; // expected-warning {{remainder by zero is undefined}}
162 x = sizeof(x/0); // no warning.
166 void test18_a(int a); // expected-note 2 {{'test18_a' declared here}}
167 void test18_b(int); // expected-note {{'test18_b' declared here}}
168 void test18_c(int a, int b); // expected-note 2 {{'test18_c' declared here}}
169 void test18_d(int a, ...); // expected-note {{'test18_d' declared here}}
170 void test18_e(int a, int b, ...); // expected-note {{'test18_e' declared here}}
172 test18_a(b, b); // expected-error {{too many arguments to function call, expected single argument 'a', have 2}}
173 test18_a(); // expected-error {{too few arguments to function call, single argument 'a' was not specified}}
174 test18_b(); // expected-error {{too few arguments to function call, expected 1, have 0}}
175 test18_c(b); // expected-error {{too few arguments to function call, expected 2, have 1}}
176 test18_c(b, b, b); // expected-error {{too many arguments to function call, expected 2, have 3}}
177 test18_d(); // expected-error {{too few arguments to function call, at least argument 'a' must be specified}}
178 test18_e(); // expected-error {{too few arguments to function call, expected at least 2, have 0}}
183 *(int*)0 = 0; // expected-warning {{indirection of non-volatile null pointer}} \
184 // expected-note {{consider using __builtin_trap}}
185 *(volatile int*)0 = 0; // Ok.
188 int x = *(int*)0; // expected-warning {{indirection of non-volatile null pointer}} \
189 // expected-note {{consider using __builtin_trap}}
190 int x2 = *(volatile int*)0; // Ok.
191 int *p = &(*(int*)0); // Ok;
195 return x && 4; // expected-warning {{use of logical '&&' with constant operand}} \
196 // expected-note {{use '&' for a bitwise operation}} \
197 // expected-note {{remove constant to silence this warning}}
199 return x && sizeof(int) == 4; // no warning, RHS is logical op.
201 // no warning, this is an idiom for "true" in old C style.
202 return x && (signed char)1;
206 return x || -1; // expected-warning {{use of logical '||' with constant operand}} \
207 // expected-note {{use '|' for a bitwise operation}}
208 return x || 5; // expected-warning {{use of logical '||' with constant operand}} \
209 // expected-note {{use '|' for a bitwise operation}}
212 return x && -1; // expected-warning {{use of logical '&&' with constant operand}} \
213 // expected-note {{use '&' for a bitwise operation}} \
214 // expected-note {{remove constant to silence this warning}}
215 return x && 5; // expected-warning {{use of logical '&&' with constant operand}} \
216 // expected-note {{use '&' for a bitwise operation}} \
217 // expected-note {{remove constant to silence this warning}}
220 return x || (-1); // expected-warning {{use of logical '||' with constant operand}} \
221 // expected-note {{use '|' for a bitwise operation}}
222 return x || (5); // expected-warning {{use of logical '||' with constant operand}} \
223 // expected-note {{use '|' for a bitwise operation}}
226 return x && (-1); // expected-warning {{use of logical '&&' with constant operand}} \
227 // expected-note {{use '&' for a bitwise operation}} \
228 // expected-note {{remove constant to silence this warning}}
229 return x && (5); // expected-warning {{use of logical '&&' with constant operand}} \
230 // expected-note {{use '&' for a bitwise operation}} \
231 // expected-note {{remove constant to silence this warning}}
235 struct Test21; // expected-note 2 {{forward declaration}}
236 void test21(volatile struct Test21 *ptr) {
237 void test21_help(void);
238 (test21_help(), *ptr); // expected-error {{incomplete type 'struct Test21' where a complete type is required}}
239 (*ptr, test21_help()); // expected-error {{incomplete type 'struct Test21' where a complete type is required}}
242 // Make sure we do function/array decay.
247 if (test22) // expected-warning {{address of function 'test22' will always evaluate to 'true'}} \
248 // expected-note {{prefix with the address-of operator to silence this warning}}