blob: 165a12b59b1fa4cece04d412adfcf7a6fe31dcd1 [file] [log] [blame]
// RUN: %clang_cc1 -Wunused-variable -analyze -analyzer-checker=core,deadcode.DeadStores,alpha.deadcode.IdempotentOperations -fblocks -verify -Wno-unreachable-code -analyzer-opt-analyze-nested-blocks %s
// RUN: %clang_cc1 -Wunused-variable -analyze -analyzer-checker=core,deadcode.DeadStores,alpha.deadcode.IdempotentOperations -analyzer-store=region -analyzer-constraints=range -fblocks -verify -Wno-unreachable-code -analyzer-opt-analyze-nested-blocks %s
void f1() {
int k, y; // expected-warning{{unused variable 'k'}} expected-warning{{unused variable 'y'}}
int abc=1;
long idx=abc+3*5; // expected-warning {{never read}} expected-warning{{unused variable 'idx'}}
}
void f2(void *b) {
char *c = (char*)b; // no-warning
char *d = b+1; // expected-warning {{never read}} expected-warning{{unused variable 'd'}}
printf("%s", c); // expected-warning{{implicitly declaring library function 'printf' with type 'int (const char *, ...)'}} \
// expected-note{{please include the header <stdio.h> or explicitly provide a declaration for 'printf'}}
}
int f();
void f3() {
int r;
if ((r = f()) != 0) { // no-warning
int y = r; // no-warning
printf("the error is: %d\n", y);
}
}
void f4(int k) {
k = 1;
if (k)
f1();
k = 2; // expected-warning {{never read}}
}
void f5() {
int x = 4; // no-warning
int *p = &x; // expected-warning{{never read}} expected-warning{{unused variable 'p'}}
}
//
int f6() {
int x = 4;
++x; // no-warning
return 1;
}
int f7(int *p) {
// This is allowed for defensive programming.
p = 0; // no-warning
return 1;
}
int f7b(int *p) {
// This is allowed for defensive programming.
p = (0); // no-warning
return 1;
}
int f7c(int *p) {
// This is allowed for defensive programming.
p = (void*) 0; // no-warning
return 1;
}
int f7d(int *p) {
// This is allowed for defensive programming.
p = (void*) (0); // no-warning
return 1;
}
// Don't warn for dead stores in nested expressions. We have yet
// to see a real bug in this scenario.
int f8(int *p) {
extern int *baz();
if ((p = baz())) // no-warning
return 1;
return 0;
}
int f9() {
int x = 4;
x = x + 10; // expected-warning{{never read}}
return 1;
}
int f10() {
int x = 4;
x = 10 + x; // expected-warning{{never read}}
return 1;
}
int f11() {
int x = 4;
return x++; // expected-warning{{never read}}
}
int f11b() {
int x = 4;
return ((((++x)))); // no-warning
}
int f12a(int y) {
int x = y; // expected-warning{{unused variable 'x'}}
return 1;
}
int f12b(int y) {
int x __attribute__((unused)) = y; // no-warning
return 1;
}
int f12c(int y) {
// Allow initialiation of scalar variables by parameters as a form of
// defensive programming.
int x = y; // no-warning
x = 1;
return x;
}
// Filed with PR 2630. This code should produce no warnings.
int f13(void)
{
int a = 1;
int b, c = b = a + a;
if (b > 0)
return (0);
return (a + b + c);
}
// Filed with PR 2763.
int f14(int count) {
int index, nextLineIndex;
for (index = 0; index < count; index = nextLineIndex+1) {
nextLineIndex = index+1; // no-warning
continue;
}
return index;
}
// Test case for <rdar://problem/6248086>
void f15(unsigned x, unsigned y) {
int count = x * y; // no-warning
int z[count]; // expected-warning{{unused variable 'z'}}
}
// Don't warn for dead stores in nested expressions. We have yet
// to see a real bug in this scenario.
int f16(int x) {
x = x * 2;
x = sizeof(int [x = (x || x + 1) * 2]) // expected-warning{{The left operand to '+' is always 0}} expected-warning{{The left operand to '*' is always 1}}
? 5 : 8;
return x;
}
// Self-assignments should not be flagged as dead stores.
void f17() {
int x = 1;
x = x;
}
// <rdar://problem/6506065>
// The values of dead stores are only "consumed" in an enclosing expression
// what that value is actually used. In other words, don't say "Although the
// value stored to 'x' is used...".
int f18() {
int x = 0; // no-warning
if (1)
x = 10; // expected-warning{{Value stored to 'x' is never read}}
while (1)
x = 10; // expected-warning{{Value stored to 'x' is never read}}
// unreachable.
do
x = 10; // no-warning
while (1);
return (x = 10); // no-warning
}
int f18_a() {
int x = 0; // no-warning
return (x = 10); // no-warning
}
void f18_b() {
int x = 0; // no-warning
if (1)
x = 10; // expected-warning{{Value stored to 'x' is never read}}
}
void f18_c() {
int x = 0;
while (1)
x = 10; // expected-warning{{Value stored to 'x' is never read}}
}
void f18_d() {
int x = 0; // no-warning
do
x = 10; // expected-warning{{Value stored to 'x' is never read}}
while (1);
}
// PR 3514: false positive `dead initialization` warning for init to global
// http://llvm.org/bugs/show_bug.cgi?id=3514
extern const int MyConstant;
int f19(void) {
int x = MyConstant; // no-warning
x = 1;
return x;
}
int f19b(void) { // This case is the same as f19.
const int MyConstant = 0;
int x = MyConstant; // no-warning
x = 1;
return x;
}
void f20(void) {
int x = 1; // no-warning
#pragma unused(x)
}
void halt() __attribute__((noreturn));
int f21() {
int x = 4;
x = x + 1; // expected-warning{{never read}}
if (1) {
halt();
(void)x;
}
return 1;
}
int j;
void f22() {
int x = 4;
int y1 = 4;
int y2 = 4;
int y3 = 4;
int y4 = 4;
int y5 = 4;
int y6 = 4;
int y7 = 4;
int y8 = 4;
int y9 = 4;
int y10 = 4;
int y11 = 4;
int y12 = 4;
int y13 = 4;
int y14 = 4;
int y15 = 4;
int y16 = 4;
int y17 = 4;
int y18 = 4;
int y19 = 4;
int y20 = 4;
x = x + 1; // expected-warning{{never read}}
++y1;
++y2;
++y3;
++y4;
++y5;
++y6;
++y7;
++y8;
++y9;
++y10;
++y11;
++y12;
++y13;
++y14;
++y15;
++y16;
++y17;
++y18;
++y19;
++y20;
switch (j) {
case 1:
if (0)
(void)x;
if (1) {
(void)y1;
return;
}
(void)x;
break;
case 2:
if (0)
(void)x;
else {
(void)y2;
return;
}
(void)x;
break;
case 3:
if (1) {
(void)y3;
return;
} else
(void)x;
(void)x;
break;
case 4:
0 ? : ((void)y4, ({ return; }));
(void)x;
break;
case 5:
1 ? : (void)x;
0 ? (void)x : ((void)y5, ({ return; }));
(void)x;
break;
case 6:
1 ? ((void)y6, ({ return; })) : (void)x;
(void)x;
break;
case 7:
(void)(0 && x);
(void)y7;
(void)(0 || (y8, ({ return; }), 1)); // expected-warning {{expression result unused}}
(void)x;
break;
case 8:
(void)(1 && (y9, ({ return; }), 1)); // expected-warning {{expression result unused}}
(void)x;
break;
case 9:
(void)(1 || x);
(void)y10;
break;
case 10:
while (0) {
(void)x;
}
(void)y11;
break;
case 11:
while (1) {
(void)y12;
}
(void)x;
break;
case 12:
do {
(void)y13;
} while (0);
(void)y14;
break;
case 13:
do {
(void)y15;
} while (1);
(void)x;
break;
case 14:
for (;;) {
(void)y16;
}
(void)x;
break;
case 15:
for (;1;) {
(void)y17;
}
(void)x;
break;
case 16:
for (;0;) {
(void)x;
}
(void)y18;
break;
case 17:
__builtin_choose_expr(0, (void)x, ((void)y19, ({ return; })));
(void)x;
break;
case 19:
__builtin_choose_expr(1, ((void)y20, ({ return; })), (void)x);
(void)x;
break;
}
}
void f23_aux(const char* s);
void f23(int argc, char **argv) {
int shouldLog = (argc > 1); // no-warning
^{
if (shouldLog) f23_aux("I did too use it!\n");
else f23_aux("I shouldn't log. Wait.. d'oh!\n");
}();
}
void f23_pos(int argc, char **argv) {
int shouldLog = (argc > 1); // expected-warning{{Value stored to 'shouldLog' during its initialization is never read}} expected-warning{{unused variable 'shouldLog'}}
^{
f23_aux("I did too use it!\n");
}();
}
void f24_A(int y) {
// FIXME: One day this should be reported as dead since 'z = x + y' is dead.
int x = (y > 2); // no-warning
^ {
int z = x + y; // expected-warning{{Value stored to 'z' during its initialization is never read}} expected-warning{{unused variable 'z'}}
}();
}
void f24_B(int y) {
// FIXME: One day this should be reported as dead since 'x' is just overwritten.
__block int x = (y > 2); // no-warning
^{
// FIXME: This should eventually be a dead store since it is never read either.
x = 5; // no-warning
}();
}
int f24_C(int y) {
// FIXME: One day this should be reported as dead since 'x' is just overwritten.
__block int x = (y > 2); // no-warning
^{
x = 5; // no-warning
}();
return x;
}
int f24_D(int y) {
__block int x = (y > 2); // no-warning
^{
if (y > 4)
x = 5; // no-warning
}();
return x;
}
// This example shows that writing to a variable captured by a block means that it might
// not be dead.
int f25(int y) {
__block int x = (y > 2);
__block int z = 0;
void (^foo)() = ^{ z = x + y; };
x = 4; // no-warning
foo();
return z;
}
// This test is mostly the same as 'f25', but shows that the heuristic of pruning out dead
// stores for variables that are just marked '__block' is overly conservative.
int f25_b(int y) {
// FIXME: we should eventually report a dead store here.
__block int x = (y > 2);
__block int z = 0;
x = 4; // no-warning
return z;
}
int f26_nestedblocks() {
int z;
z = 1;
__block int y = 0;
^{
int k;
k = 1; // expected-warning{{Value stored to 'k' is never read}}
^{
y = z + 1;
}();
}();
return y;
}
// The FOREACH macro in QT uses 'break' statements within statement expressions
// placed within the increment code of for loops.
void rdar8014335() {
for (int i = 0 ; i != 10 ; ({ break; })) {
for ( ; ; ({ ++i; break; })) ;
// Note that the next value stored to 'i' is never executed
// because the next statement to be executed is the 'break'
// in the increment code of the first loop.
i = i * 3; // expected-warning{{Value stored to 'i' is never read}} expected-warning{{The left operand to '*' is always 1}}
}
}
// <rdar://problem/8320674> NullStmts followed by do...while() can lead to disconnected CFG
//
// This previously caused bogus dead-stores warnings because the body of the first do...while was
// disconnected from the entry of the function.
typedef struct { float r; float i; } s_rdar8320674;
typedef struct { s_rdar8320674 x[1]; } s2_rdar8320674;
void rdar8320674(s_rdar8320674 *z, unsigned y, s2_rdar8320674 *st, int m)
{
s_rdar8320674 * z2;
s_rdar8320674 * tw1 = st->x;
s_rdar8320674 t;
z2 = z + m;
do{
; ;
do{ (t).r = (*z2).r*(*tw1).r - (*z2).i*(*tw1).i; (t).i = (*z2).r*(*tw1).i + (*z2).i*(*tw1).r; }while(0);
tw1 += y;
do { (*z2).r=(*z).r-(t).r; (*z2).i=(*z).i-(t).i; }while(0);
do { (*z).r += (t).r; (*z).i += (t).i; }while(0);
++z2;
++z;
}while (--m);
}
// Avoid dead stores resulting from an assignment (and use) being unreachable.
void rdar8405222_aux(int i);
void rdar8405222() {
const int show = 0;
int i = 0;
if (show)
i = 5; // no-warning
if (show)
rdar8405222_aux(i);
}
// Look through chains of assignements, e.g.: int x = y = 0, when employing
// silencing heuristics.
int radar11185138_foo() {
int x, y;
x = y = 0; // expected-warning {{never read}}
return y;
}
int rdar11185138_bar() {
int y;
int x = y = 0; // no-warning
x = 2;
y = 2;
return x + y;
}
int *radar11185138_baz() {
int *x, *y;
x = y = 0; // no-warning
return y;
}