forked from OSchip/llvm-project
679 lines
15 KiB
C
679 lines
15 KiB
C
// RUN: %check_analyzer_fixit %s %t \
|
|
// RUN: -Wunused-variable -fblocks -Wno-unreachable-code \
|
|
// RUN: -analyzer-checker=core,deadcode.DeadStores \
|
|
// RUN: -analyzer-config deadcode.DeadStores:ShowFixIts=true \
|
|
// RUN: -analyzer-config \
|
|
// RUN: deadcode.DeadStores:WarnForDeadNestedAssignments=false \
|
|
// RUN: -verify=non-nested
|
|
|
|
// RUN: %check_analyzer_fixit %s %t \
|
|
// RUN: -Wunused-variable -fblocks -Wno-unreachable-code \
|
|
// RUN: -analyzer-checker=core,deadcode.DeadStores \
|
|
// RUN: -analyzer-config deadcode.DeadStores:ShowFixIts=true \
|
|
// RUN: -verify=non-nested,nested
|
|
|
|
void f1() {
|
|
int k, y; // non-nested-warning {{unused variable 'k'}}
|
|
// non-nested-warning@-1 {{unused variable 'y'}}
|
|
int abc = 1;
|
|
long idx = abc + 3 * 5; // non-nested-warning {{never read}}
|
|
// non-nested-warning@-1 {{unused variable 'idx'}}
|
|
// CHECK-FIXES: int abc = 1;
|
|
// CHECK-FIXES-NEXT: long idx;
|
|
}
|
|
|
|
void f2(void *b) {
|
|
char *c = (char *)b; // no-warning
|
|
char *d = b + 1; // non-nested-warning {{never read}}
|
|
// non-nested-warning@-1 {{unused variable 'd'}}
|
|
// CHECK-FIXES: char *c = (char *)b;
|
|
// CHECK-FIXES-NEXT: char *d;
|
|
|
|
printf("%s", c);
|
|
// non-nested-warning@-1 {{implicitly declaring library function 'printf' with type 'int (const char *, ...)'}}
|
|
// non-nested-note@-2 {{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; // non-nested-warning {{never read}}
|
|
}
|
|
|
|
void f5() {
|
|
int x = 4; // no-warning
|
|
int *p = &x; // non-nested-warning {{never read}}
|
|
// non-nested-warning@-1 {{unused variable 'p'}}
|
|
// CHECK-FIXES: int x = 4;
|
|
// CHECK-FIXES-NEXT: int *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;
|
|
}
|
|
|
|
// Warn for dead stores in nested expressions.
|
|
int f8(int *p) {
|
|
extern int *baz();
|
|
if ((p = baz())) // nested-warning {{Although the value stored}}
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
int f9() {
|
|
int x = 4;
|
|
x = x + 10; // non-nested-warning {{never read}}
|
|
return 1;
|
|
}
|
|
|
|
int f10() {
|
|
int x = 4;
|
|
x = 10 + x; // non-nested-warning {{never read}}
|
|
return 1;
|
|
}
|
|
|
|
int f11() {
|
|
int x = 4;
|
|
return x++; // non-nested-warning {{never read}}
|
|
}
|
|
|
|
int f11b() {
|
|
int x = 4;
|
|
return ((((++x)))); // no-warning
|
|
}
|
|
|
|
int f12a(int y) {
|
|
int x = y; // non-nested-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]; // non-nested-warning {{unused variable 'z'}}
|
|
}
|
|
|
|
// Warn for dead stores in nested expressions.
|
|
int f16(int x) {
|
|
x = x * 2;
|
|
x = sizeof(int[x = (x || x + 1) * 2]) ? 5 : 8;
|
|
// nested-warning@-1 {{Although the value stored}}
|
|
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; // non-nested-warning {{Value stored to 'x' is never read}}
|
|
while (1)
|
|
x = 10; // non-nested-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); // nested-warning {{Although the value stored}}
|
|
}
|
|
|
|
void f18_b() {
|
|
int x = 0; // no-warning
|
|
if (1)
|
|
x = 10; // non-nested-warning {{Value stored to 'x' is never read}}
|
|
}
|
|
|
|
void f18_c() {
|
|
int x = 0;
|
|
while (1)
|
|
x = 10; // non-nested-warning {{Value stored to 'x' is never read}}
|
|
}
|
|
|
|
void f18_d() {
|
|
int x = 0; // no-warning
|
|
do
|
|
x = 10; // non-nested-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; // non-nested-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; // non-nested-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));
|
|
// non-nested-warning@-1 {{expression result unused}}
|
|
(void)x;
|
|
break;
|
|
case 8:
|
|
(void)(1 && (y9, ({ return; }), 1));
|
|
// non-nested-warning@-1 {{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);
|
|
// non-nested-warning@-1 {{Value stored to 'shouldLog' during its initialization is never read}}
|
|
// non-nested-warning@-2 {{unused variable 'shouldLog'}}
|
|
// CHECK-FIXES: void f23_pos(int argc, char **argv) {
|
|
// CHECK-FIXES-NEXT: int 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;
|
|
// non-nested-warning@-1 {{Value stored to 'z' during its initialization is never read}}
|
|
// non-nested-warning@-2 {{unused variable 'z'}}
|
|
// CHECK-FIXES: void f24_A(int y) {
|
|
// CHECK-FIXES-NEXT: //
|
|
// CHECK-FIXES-NEXT: int x = (y > 2);
|
|
// CHECK-FIXES-NEXT: ^{
|
|
// CHECK-FIXES-NEXT: int 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; // non-nested-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; }))
|
|
;
|
|
// non-nested-warning@-2 {{'break' is bound to current loop, GCC binds it to the enclosing loop}}
|
|
// 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; // non-nested-warning {{Value stored to 'i' is never read}}
|
|
}
|
|
}
|
|
|
|
// <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 assignments, e.g.: int x = y = 0, when employing
|
|
// silencing heuristics.
|
|
int radar11185138_foo() {
|
|
int x, y;
|
|
x = y = 0; // non-nested-warning {{never read}}
|
|
return y;
|
|
}
|
|
|
|
int rdar11185138_bar() {
|
|
int y;
|
|
int x = y = 0; // nested-warning {{Although the value stored}}
|
|
x = 2;
|
|
y = 2;
|
|
return x + y;
|
|
}
|
|
|
|
int *radar11185138_baz() {
|
|
int *x, *y;
|
|
x = y = 0; // no-warning
|
|
return y;
|
|
}
|
|
|
|
int getInt();
|
|
int *getPtr();
|
|
void testBOComma() {
|
|
int x0 = (getInt(), 0); // non-nested-warning {{unused variable 'x0'}}
|
|
int x1 = (getInt(), getInt());
|
|
// non-nested-warning@-1 {{Value stored to 'x1' during its initialization is never read}}
|
|
// non-nested-warning@-2 {{unused variable 'x1'}}
|
|
|
|
int x2 = (getInt(), getInt(), getInt());
|
|
// non-nested-warning@-1 {{Value stored to 'x2' during its initialization is never read}}
|
|
// non-nested-warning@-2 {{unused variable 'x2'}}
|
|
|
|
int x3;
|
|
x3 = (getInt(), getInt(), 0);
|
|
// non-nested-warning@-1 {{Value stored to 'x3' is never read}}
|
|
|
|
int x4 = (getInt(), (getInt(), 0));
|
|
// non-nested-warning@-1 {{unused variable 'x4'}}
|
|
|
|
int y;
|
|
int x5 = (getInt(), (y = 0));
|
|
// non-nested-warning@-1 {{unused variable 'x5'}}
|
|
// nested-warning@-2 {{Although the value stored}}
|
|
|
|
int x6 = (getInt(), (y = getInt()));
|
|
// non-nested-warning@-1 {{Value stored to 'x6' during its initialization is never read}}
|
|
// non-nested-warning@-2 {{unused variable 'x6'}}
|
|
// nested-warning@-3 {{Although the value stored}}
|
|
|
|
int x7 = 0, x8 = getInt();
|
|
// non-nested-warning@-1 {{Value stored to 'x8' during its initialization is never read}}
|
|
// non-nested-warning@-2 {{unused variable 'x8'}}
|
|
// non-nested-warning@-3 {{unused variable 'x7'}}
|
|
|
|
int x9 = getInt(), x10 = 0;
|
|
// non-nested-warning@-1 {{Value stored to 'x9' during its initialization is never read}}
|
|
// non-nested-warning@-2 {{unused variable 'x9'}}
|
|
// non-nested-warning@-3 {{unused variable 'x10'}}
|
|
|
|
int m = getInt(), mm, mmm;
|
|
// non-nested-warning@-1 {{Value stored to 'm' during its initialization is never read}}
|
|
// non-nested-warning@-2 {{unused variable 'm'}}
|
|
// non-nested-warning@-3 {{unused variable 'mm'}}
|
|
// non-nested-warning@-4 {{unused variable 'mmm'}}
|
|
|
|
int n, nn = getInt();
|
|
// non-nested-warning@-1 {{Value stored to 'nn' during its initialization is never read}}
|
|
// non-nested-warning@-2 {{unused variable 'n'}}
|
|
// non-nested-warning@-3 {{unused variable 'nn'}}
|
|
|
|
int *p;
|
|
p = (getPtr(), (int *)0); // no warning
|
|
}
|
|
|
|
void testVolatile() {
|
|
volatile int v;
|
|
v = 0; // no warning
|
|
}
|
|
|
|
struct Foo {
|
|
int x;
|
|
int y;
|
|
};
|
|
|
|
struct Foo rdar34122265_getFoo(void);
|
|
|
|
int rdar34122265_test(int input) {
|
|
// This is allowed for defensive programming.
|
|
struct Foo foo = {0, 0};
|
|
if (input > 0) {
|
|
foo = rdar34122265_getFoo();
|
|
} else {
|
|
return 0;
|
|
}
|
|
return foo.x + foo.y;
|
|
}
|
|
|
|
void rdar34122265_test_cast() {
|
|
// This is allowed for defensive programming.
|
|
struct Foo foo = {0, 0};
|
|
(void)foo;
|
|
}
|
|
|
|
struct Bar {
|
|
struct Foo x, y;
|
|
};
|
|
|
|
struct Bar rdar34122265_getBar(void);
|
|
|
|
int rdar34122265_test_nested(int input) {
|
|
// This is allowed for defensive programming.
|
|
struct Bar bar = {{0, 0}, {0, 0}};
|
|
if (input > 0) {
|
|
bar = rdar34122265_getBar();
|
|
} else {
|
|
return 0;
|
|
}
|
|
return bar.x.x + bar.y.y;
|
|
}
|