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 __extension__ ({ R = (__typeof__(P->x)) 2; }); // expected-error {{invalid application of 'typeof' to bit-field}} 101 return R; 102} 103 104// PR3562 105void 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 115struct mystruct {int A; }; 116void 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 121int test12(const char *X) { 122 return X == "foo"; // expected-warning {{comparison against a string literal is unspecified (use strncmp instead)}} 123} 124 125int test12b(const char *X) { 126 return sizeof(X == "foo"); // no-warning 127} 128 129// rdar://6719156 130void 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 136void 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 147typedef unsigned long *test15_t; 148 149test15_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 154void test16(float x) { x == ((void*) 0); } // expected-error {{invalid operands to binary expression}} 155 156// PR6004 157void 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 167void test18_a(int a); // expected-note 2 {{'test18_a' declared here}} 168void test18_b(int); // expected-note {{'test18_b' declared here}} 169void test18_c(int a, int b); // expected-note 2 {{'test18_c' declared here}} 170void test18_d(int a, ...); // expected-note {{'test18_d' declared here}} 171void test18_e(int a, int b, ...); // expected-note {{'test18_e' declared here}} 172void test18(int b) { 173 test18_a(b, b); // expected-error {{too many arguments to function call, expected single argument 'a', have 2}} 174 test18_a(); // expected-error {{too few arguments to function call, single argument 'a' was not specified}} 175 test18_b(); // expected-error {{too few arguments to function call, expected 1, have 0}} 176 test18_c(b); // expected-error {{too few arguments to function call, expected 2, have 1}} 177 test18_c(b, b, b); // expected-error {{too many arguments to function call, expected 2, have 3}} 178 test18_d(); // expected-error {{too few arguments to function call, at least argument 'a' must be specified}} 179 test18_e(); // expected-error {{too few arguments to function call, expected at least 2, have 0}} 180} 181 182// PR7569 183void test19() { 184 *(int*)0 = 0; // expected-warning {{indirection of non-volatile null pointer}} \ 185 // expected-note {{consider using __builtin_trap}} 186 *(volatile int*)0 = 0; // Ok. 187 188 // rdar://9269271 189 int x = *(int*)0; // expected-warning {{indirection of non-volatile null pointer}} \ 190 // expected-note {{consider using __builtin_trap}} 191 int x2 = *(volatile int*)0; // Ok. 192 int *p = &(*(int*)0); // Ok; 193} 194 195int test20(int x) { 196 return x && 4; // expected-warning {{use of logical '&&' with constant operand}} \ 197 // expected-note {{use '&' for a bitwise operation}} \ 198 // expected-note {{remove constant to silence this warning}} 199 200 return x && sizeof(int) == 4; // no warning, RHS is logical op. 201 202 // no warning, this is an idiom for "true" in old C style. 203 return x && (signed char)1; 204 205 return x || 0; 206 return x || 1; 207 return x || -1; // expected-warning {{use of logical '||' with constant operand}} \ 208 // expected-note {{use '|' for a bitwise operation}} 209 return x || 5; // expected-warning {{use of logical '||' with constant operand}} \ 210 // expected-note {{use '|' for a bitwise operation}} 211 return x && 0; 212 return x && 1; 213 return x && -1; // expected-warning {{use of logical '&&' with constant operand}} \ 214 // expected-note {{use '&' for a bitwise operation}} \ 215 // expected-note {{remove constant to silence this warning}} 216 return x && 5; // expected-warning {{use of logical '&&' with constant operand}} \ 217 // expected-note {{use '&' for a bitwise operation}} \ 218 // expected-note {{remove constant to silence this warning}} 219 return x || (0); 220 return x || (1); 221 return x || (-1); // expected-warning {{use of logical '||' with constant operand}} \ 222 // expected-note {{use '|' for a bitwise operation}} 223 return x || (5); // expected-warning {{use of logical '||' with constant operand}} \ 224 // expected-note {{use '|' for a bitwise operation}} 225 return x && (0); 226 return x && (1); 227 return x && (-1); // expected-warning {{use of logical '&&' with constant operand}} \ 228 // expected-note {{use '&' for a bitwise operation}} \ 229 // expected-note {{remove constant to silence this warning}} 230 return x && (5); // expected-warning {{use of logical '&&' with constant operand}} \ 231 // expected-note {{use '&' for a bitwise operation}} \ 232 // expected-note {{remove constant to silence this warning}} 233 234} 235 236struct Test21; // expected-note 2 {{forward declaration}} 237void test21(volatile struct Test21 *ptr) { 238 void test21_help(void); 239 (test21_help(), *ptr); // expected-error {{incomplete type 'struct Test21' where a complete type is required}} 240 (*ptr, test21_help()); // expected-error {{incomplete type 'struct Test21' where a complete type is required}} 241} 242 243// Make sure we do function/array decay. 244void test22() { 245 if ("help") 246 (void) 0; 247 248 if (test22) // expected-warning {{address of function 'test22' will always evaluate to 'true'}} \ 249 // expected-note {{prefix with the address-of operator to silence this warning}} 250 (void) 0; 251 252 if (&test22) 253 (void) 0; 254} 255