1// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only
2
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;\
8  } while (0)
9
10#define PR8876_pos(err_ptr) do {\
11    if (!err_ptr) *(int*)(err_ptr) = 1;\
12  } while (0)
13
14
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.
17void radar9171946() {
18  if (0) {
19    0 / (0 ? 1 : 0); // expected-warning {{expression result unused}}
20  }
21}
22
23int test_pr8876() {
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'}}
26  return 0;
27}
28
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.
31void pr8183(unsigned long long test)
32{
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'}}
35}
36
37// PR1966
38_Complex double test1() {
39  return __extension__ 1.0if;
40}
41
42_Complex double test2() {
43  return 1.0if;    // expected-warning {{imaginary constants are a GNU extension}}
44}
45
46// rdar://6097308
47void test3() {
48  int x;
49  (__extension__ x) = 10;
50}
51
52// rdar://6162726
53void test4() {
54      static int var;
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 +.
58      var = -5;
59
60      var =+5;  // no warning when the subexpr of the unary op has no space before it.
61      var =-5;
62
63#define FIVE 5
64      var=-FIVE;  // no warning with macros.
65      var=-FIVE;
66}
67
68// rdar://6319320
69void 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}}
73}
74
75void test6() {
76  int X;
77  X();  // expected-error {{called object type 'int' is not a function or function pointer}}
78}
79
80void test7(int *P, _Complex float Gamma) {
81   P = (P-42) + Gamma*4;  // expected-error {{invalid operands to binary expression ('int *' and '_Complex float')}}
82}
83
84
85// rdar://6095061
86int test8(void) {
87  int i;
88  __builtin_choose_expr (0, 42, i) = 10;
89  return i;
90}
91
92
93// PR3386
94struct f { int x : 4;  float y[]; };
95int test9(struct f *P) {
96  int R;
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}}
100  return R;
101}
102
103// PR3562
104void test10(int n,...) {
105  struct S {
106    double          a[n];  // expected-error {{fields must have a constant size}}
107  }               s;
108  double x = s.a[0];  // should not get another error here.
109}
110
111
112#define MYMAX(A,B)    __extension__ ({ __typeof__(A) __a = (A); __typeof__(B) __b = (B); __a < __b ? __b : __a; })
113
114struct mystruct {int A; };
115void 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'))}}
117}
118
119// PR3753
120int test12(const char *X) {
121  return X == "foo";  // expected-warning {{comparison against a string literal is unspecified (use strncmp instead)}}
122}
123
124int test12b(const char *X) {
125  return sizeof(X == "foo"); // no-warning
126}
127
128// rdar://6719156
129void test13(
130            void (^P)()) { // expected-error {{blocks support disabled - compile with -fblocks}}
131  P();
132  P = ^(){}; // expected-error {{blocks support disabled - compile with -fblocks}}
133}
134
135void test14() {
136  typedef long long __m64 __attribute__((__vector_size__(8)));
137  typedef short __v4hi __attribute__((__vector_size__(8)));
138
139  // Ok.
140  __v4hi a;
141  __m64 mask = (__m64)((__v4hi)a > (__v4hi)a);
142}
143
144
145// PR5242
146typedef unsigned long *test15_t;
147
148test15_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')}}
150}
151
152// rdar://7446395
153void test16(float x) { x == ((void*) 0); }  // expected-error {{invalid operands to binary expression}}
154
155// PR6004
156void test17(int x) {
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}}
161
162  x = sizeof(x/0);  // no warning.
163}
164
165// PR6501 & PR11857
166void test18_a(int a); // expected-note 2 {{'test18_a' declared here}}
167void test18_b(int); // expected-note {{'test18_b' declared here}}
168void test18_c(int a, int b); // expected-note 2 {{'test18_c' declared here}}
169void test18_d(int a, ...); // expected-note {{'test18_d' declared here}}
170void test18_e(int a, int b, ...); // expected-note {{'test18_e' declared here}}
171void test18(int b) {
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}}
179}
180
181// PR7569
182void test19() {
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.
186
187  // rdar://9269271
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;
192}
193
194int test20(int x) {
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}}
198
199  return x && sizeof(int) == 4;  // no warning, RHS is logical op.
200
201  // no warning, this is an idiom for "true" in old C style.
202  return x && (signed char)1;
203
204  return x || 0;
205  return x || 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}}
210  return x && 0;
211  return x && 1;
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}}
218  return x || (0);
219  return x || (1);
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}}
224  return x && (0);
225  return x && (1);
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}}
232
233}
234
235struct Test21; // expected-note 2 {{forward declaration}}
236void 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}}
240}
241
242// Make sure we do function/array decay.
243void test22() {
244  if ("help")
245    (void) 0;
246
247  if (test22)
248    (void) 0;
249}
250