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.
radar9171946()17 void radar9171946() {
18   if (0) {
19     0 / (0 ? 1 : 0); // expected-warning {{expression result unused}}
20   }
21 }
22 
test_pr8876()23 int 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.
pr8183(unsigned long long test)31 void 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
test1()38 _Complex double test1() {
39   return __extension__ 1.0if;
40 }
41 
test2()42 _Complex double test2() {
43   return 1.0if;    // expected-warning {{imaginary constants are a GNU extension}}
44 }
45 
46 // rdar://6097308
test3()47 void test3() {
48   int x;
49   (__extension__ x) = 10;
50 }
51 
52 // rdar://6162726
test4()53 void 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
test5(int * X,float * P)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}}
73 }
74 
test6()75 void test6() {
76   int X;
77   X();  // expected-error {{called object type 'int' is not a function or function pointer}}
78 }
79 
test7(int * P,_Complex float Gamma)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')}}
82 }
83 
84 
85 // rdar://6095061
test8(void)86 int test8(void) {
87   int i;
88   __builtin_choose_expr (0, 42, i) = 10;
89   return i;
90 }
91 
92 
93 // PR3386
94 struct f { int x : 4;  float y[]; };
test9(struct f * P)95 int 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   __extension__ ({ R = (__typeof__(P->x)) 2; }); // expected-error {{invalid application of 'typeof' to bit-field}}
101   return R;
102 }
103 
104 // PR3562
test10(int n,...)105 void test10(int n,...) {
106   struct S {
107     double          a[n];  // expected-error {{fields must have a constant size}}
108   }               s;
109   double x = s.a[0];  // should not get another error here.
110 }
111 
112 
113 #define MYMAX(A,B)    __extension__ ({ __typeof__(A) __a = (A); __typeof__(B) __b = (B); __a < __b ? __b : __a; })
114 
115 struct mystruct {int A; };
test11(struct mystruct P,float F)116 void test11(struct mystruct P, float F) {
117   MYMAX(P, F);  // expected-error {{invalid operands to binary expression ('typeof (P)' (aka 'struct mystruct') and 'typeof (F)' (aka 'float'))}}
118 }
119 
120 // PR3753
test12(const char * X)121 int test12(const char *X) {
122   return X == "foo";  // expected-warning {{comparison against a string literal is unspecified (use an explicit string comparison function instead)}}
123 }
124 
test12b(const char * X)125 int test12b(const char *X) {
126   return sizeof(X == "foo"); // no-warning
127 }
128 
129 // rdar://6719156
130 void test13(
131             void (^P)()) { // expected-error {{blocks support disabled - compile with -fblocks}}
132   P();
133   P = ^(){}; // expected-error {{blocks support disabled - compile with -fblocks}}
134 }
135 
test14()136 void test14() {
137   typedef long long __m64 __attribute__((__vector_size__(8)));
138   typedef short __v4hi __attribute__((__vector_size__(8)));
139 
140   // Ok.
141   __v4hi a;
142   __m64 mask = (__m64)((__v4hi)a > (__v4hi)a);
143 }
144 
145 
146 // PR5242
147 typedef unsigned long *test15_t;
148 
test15(void)149 test15_t test15(void) {
150   return (test15_t)0 + (test15_t)0;  // expected-error {{invalid operands to binary expression ('test15_t' (aka 'unsigned long *') and 'test15_t')}}
151 }
152 
153 // rdar://7446395
test16(float x)154 void test16(float x) { x == ((void*) 0); }  // expected-error {{invalid operands to binary expression}}
155 
156 // PR6004
test17(int x)157 void test17(int x) {
158   x = x / 0;  // expected-warning {{division by zero is undefined}}
159   x = x % 0;  // expected-warning {{remainder by zero is undefined}}
160   x /= 0;  // expected-warning {{division by zero is undefined}}
161   x %= 0;  // expected-warning {{remainder by zero is undefined}}
162 
163   x = sizeof(x/0);  // no warning.
164 }
165 
166 // PR6501, PR11857, and PR23564
167 void test18_a(int a); // expected-note 2 {{'test18_a' declared here}}
168 void test18_b(int); // expected-note {{'test18_b' declared here}}
169 void test18_c(int a, int b); // expected-note 2 {{'test18_c' declared here}}
170 void test18_d(int a, ...); // expected-note {{'test18_d' declared here}}
171 void test18_e(int a, int b, ...); // expected-note {{'test18_e' declared here}}
172 #define MY_EXPORT __attribute__((visibility("default")))
173 MY_EXPORT void // (no "declared here" notes on this line, no "expanded from MY_EXPORT" notes either)
174 test18_f(int a, int b); // expected-note 2 {{'test18_f' declared here}}
test18(int b)175 void test18(int b) {
176   test18_a(b, b); // expected-error {{too many arguments to function call, expected single argument 'a', have 2}}
177   test18_a(); // expected-error {{too few arguments to function call, single argument 'a' was not specified}}
178   test18_b(); // expected-error {{too few arguments to function call, expected 1, have 0}}
179   test18_c(b); // expected-error {{too few arguments to function call, expected 2, have 1}}
180   test18_c(b, b, b); // expected-error {{too many arguments to function call, expected 2, have 3}}
181   test18_d(); // expected-error {{too few arguments to function call, at least argument 'a' must be specified}}
182   test18_e(); // expected-error {{too few arguments to function call, expected at least 2, have 0}}
183   test18_f(b); // expected-error {{too few arguments to function call, expected 2, have 1}}
184   test18_f(b, b, b); // expected-error {{too many arguments to function call, expected 2, have 3}}
185 }
186 
187 typedef int __attribute__((address_space(256))) int_AS256;
188 // PR7569
test19()189 void test19() {
190   *(int *)0 = 0;                                     // expected-warning {{indirection of non-volatile null pointer}} \
191                   // expected-note {{consider using __builtin_trap}}
192   *(volatile int *)0 = 0;                            // Ok.
193   *(int __attribute__((address_space(256))) *)0 = 0; // Ok.
194   *(int __attribute__((address_space(0))) *)0 = 0;   // expected-warning {{indirection of non-volatile null pointer}} \
195                      // expected-note {{consider using __builtin_trap}}
196   *(int_AS256 *)0 = 0;                               // Ok.
197 
198   // rdar://9269271
199   int x = *(int *)0;                                                                          // expected-warning {{indirection of non-volatile null pointer}} \
200                      // expected-note {{consider using __builtin_trap}}
201   int x2 = *(volatile int *)0;                                                                // Ok.
202   int x3 = *(int __attribute__((address_space(0))) *)0;                                       // expected-warning {{indirection of non-volatile null pointer}} \
203                      // expected-note {{consider using __builtin_trap}}
204   int x4 = *(int_AS256 *)0;                                                                   // Ok.
205   int *p = &(*(int *)0);                                                                      // Ok.
206   int_AS256 *p1 = &(*(int __attribute__((address_space(256))) *)0);                           // Ok.
207   int __attribute__((address_space(0))) *p2 = &(*(int __attribute__((address_space(0))) *)0); // Ok.
208 }
209 
test20(int x)210 int test20(int x) {
211   return x && 4; // expected-warning {{use of logical '&&' with constant operand}} \
212                  // expected-note {{use '&' for a bitwise operation}} \
213                  // expected-note {{remove constant to silence this warning}}
214 
215   return x && sizeof(int) == 4;  // no warning, RHS is logical op.
216 
217   // no warning, this is an idiom for "true" in old C style.
218   return x && (signed char)1;
219 
220   return x || 0;
221   return x || 1;
222   return x || -1; // expected-warning {{use of logical '||' with constant operand}} \
223                   // expected-note {{use '|' for a bitwise operation}}
224   return x || 5; // expected-warning {{use of logical '||' with constant operand}} \
225                  // expected-note {{use '|' for a bitwise operation}}
226   return x && 0;
227   return x && 1;
228   return x && -1; // expected-warning {{use of logical '&&' with constant operand}} \
229                   // expected-note {{use '&' for a bitwise operation}} \
230                   // expected-note {{remove constant to silence this warning}}
231   return x && 5; // expected-warning {{use of logical '&&' with constant operand}} \
232                  // expected-note {{use '&' for a bitwise operation}} \
233                  // expected-note {{remove constant to silence this warning}}
234   return x || (0);
235   return x || (1);
236   return x || (-1); // expected-warning {{use of logical '||' with constant operand}} \
237                     // expected-note {{use '|' for a bitwise operation}}
238   return x || (5); // expected-warning {{use of logical '||' with constant operand}} \
239                    // expected-note {{use '|' for a bitwise operation}}
240   return x && (0);
241   return x && (1);
242   return x && (-1); // expected-warning {{use of logical '&&' with constant operand}} \
243                     // expected-note {{use '&' for a bitwise operation}} \
244                     // expected-note {{remove constant to silence this warning}}
245   return x && (5); // expected-warning {{use of logical '&&' with constant operand}} \
246                    // expected-note {{use '&' for a bitwise operation}} \
247                    // expected-note {{remove constant to silence this warning}}
248 
249 }
250 
251 struct Test21; // expected-note 2 {{forward declaration}}
test21(volatile struct Test21 * ptr)252 void test21(volatile struct Test21 *ptr) {
253   void test21_help(void);
254   (test21_help(), *ptr); // expected-error {{incomplete type 'struct Test21' where a complete type is required}}
255   (*ptr, test21_help()); // expected-error {{incomplete type 'struct Test21' where a complete type is required}}
256 }
257 
258 // Make sure we do function/array decay.
test22()259 void test22() {
260   if ("help")
261     (void) 0;
262 
263   if (test22) // expected-warning {{address of function 'test22' will always evaluate to 'true'}} \
264 	      // expected-note {{prefix with the address-of operator to silence this warning}}
265     (void) 0;
266 
267   if (&test22)
268     (void) 0;
269 }
270