blob: faf94c024bc63117340aba17d147cc940e4d7e0e (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
|
// RUN: %clang_cc1 -fsyntax-only -Wuninitialized-experimental -fsyntax-only %s -verify
int test1() {
int x; // expected-warning{{use of uninitialized variable 'x'}} expected-note{{add initialization to silence this warning}}
return x; // expected-note{{variable 'x' is possibly uninitialized when used here}}
}
int test2() {
int x = 0;
return x; // no-warning
}
int test3() {
int x;
x = 0;
return x; // no-warning
}
int test4() {
int x; // expected-warning{{use of uninitialized variable 'x'}} expected-note{{add initialization to silence this warning}}
++x; // expected-note{{variable 'x' is possibly uninitialized when used here}}
return x;
}
int test5() {
int x, y; // expected-warning{{use of uninitialized variable 'y'}} expected-note{{add initialization to silence this warning}}
x = y; // expected-note{{variable 'y' is possibly uninitialized when used here}}
return x;
}
int test6() {
int x; // expected-warning{{use of uninitialized variable 'x'}} expected-note{{add initialization to silence this warning}}
x += 2; // expected-note{{variable 'x' is possibly uninitialized when used here}}
return x;
}
int test7(int y) {
int x; // expected-warning{{use of uninitialized variable 'x'}} expected-note{{add initialization to silence this warning}}
if (y)
x = 1;
return x; // expected-note{{variable 'x' is possibly uninitialized when used here}}
}
int test8(int y) {
int x;
if (y)
x = 1;
else
x = 0;
return x; // no-warning
}
int test9(int n) {
int x; // expected-warning{{use of uninitialized variable 'x'}} expected-note{{add initialization to silence this warning}}
for (unsigned i = 0 ; i < n; ++i) {
if (i == n - 1)
break;
x = 1;
}
return x; // expected-note{{variable 'x' is possibly uninitialized when used here}}
}
int test10(unsigned n) {
int x; // expected-warning{{use of uninitialized variable 'x'}} expected-note{{add initialization to silence this warning}}
for (unsigned i = 0 ; i < n; ++i) {
x = 1;
}
return x; // expected-note{{variable 'x' is possibly uninitialized when used here}}
}
int test11(unsigned n) {
int x; // expected-warning{{use of uninitialized variable 'x'}} expected-note{{add initialization to silence this warning}}
for (unsigned i = 0 ; i <= n; ++i) {
x = 1;
}
return x; //expected-note{{variable 'x' is possibly uninitialized when used here}}
}
void test12(unsigned n) {
for (unsigned i ; n ; ++i) ; // expected-warning{{use of uninitialized variable 'i'}} expected-note{{variable 'i' is possibly uninitialized when used here}}} expected-note{{add initialization to silence this warning}}
}
int test13() {
static int i;
return i; // no-warning
}
// Simply don't crash on this test case.
void test14() {
const char *p = 0;
for (;;) {}
}
void test15() {
int x = x; // expected-warning{{use of uninitialized variable 'x'}} expected-note{{variable 'x' is possibly uninitialized when used here}} expected-note{{add initialization to silence this warning}}
}
// Don't warn in the following example; shows dataflow confluence.
char *test16_aux();
void test16() {
char *p = test16_aux();
for (unsigned i = 0 ; i < 100 ; i++)
p[i] = 'a'; // no-warning
}
void test17() {
// Don't warn multiple times about the same uninitialized variable
// along the same path.
int *x; // expected-warning{{use of uninitialized variable 'x'}} expected-note{{add initialization to silence this warning}}
*x = 1; // expected-note{{variable 'x' is possibly uninitialized when used here}}
*x = 1; // no-warning
}
int test18(int x, int y) {
int z;
if (x && y && (z = 1)) {
return z; // no-warning
}
return 0;
}
int test19_aux1();
int test19_aux2();
int test19_aux3(int *x);
int test19() {
int z;
if (test19_aux1() + test19_aux2() && test19_aux1() && test19_aux3(&z))
return z; // no-warning
return 0;
}
int test20() {
int z; // expected-warning{{use of uninitialized variable 'z'}} expected-note{{add initialization to silence this warning}}
if ((test19_aux1() + test19_aux2() && test19_aux1()) || test19_aux3(&z))
return z; // expected-note{{variable 'z' is possibly uninitialized when used here}}
return 0;
}
int test21(int x, int y) {
int z; // expected-warning{{use of uninitialized variable 'z'}} expected-note{{add initialization to silence this warning}}
if ((x && y) || test19_aux3(&z) || test19_aux2())
return z; // expected-note{{variable 'z' is possibly uninitialized when used here}}
return 0;
}
int test22() {
int z;
while (test19_aux1() + test19_aux2() && test19_aux1() && test19_aux3(&z))
return z; // no-warning
return 0;
}
int test23() {
int z;
for ( ; test19_aux1() + test19_aux2() && test19_aux1() && test19_aux3(&z) ; )
return z; // no-warning
return 0;
}
// The basic uninitialized value analysis doesn't have enough path-sensitivity
// to catch initializations relying on control-dependencies spanning multiple
// conditionals. This possibly can be handled by making the CFG itself
// represent such control-dependencies, but it is a niche case.
int test24(int flag) {
unsigned val; // expected-warning{{use of uninitialized variable 'val'}} expected-note{{add initialization to silence this warning}}
if (flag)
val = 1;
if (!flag)
val = 1;
return val; // expected-note{{variable 'val' is possibly uninitialized when used here}}
}
float test25() {
float x; // expected-warning{{use of uninitialized variable 'x'}} expected-note{{add initialization to silence this warning}}
return x; // expected-note{{variable 'x' is possibly uninitialized when used here}}
}
typedef int MyInt;
MyInt test26() {
MyInt x; // expected-warning{{use of uninitialized variable 'x'}} expected-note{{add initialization to silence this warning}}
return x; // expected-note{{variable 'x' is possibly uninitialized when used here}}
}
// Test handling of sizeof().
int test27() {
struct test_27 { int x; } *y;
return sizeof(y->x); // no-warning
}
int test28() {
int len; // expected-warning{{use of uninitialized variable 'len'}} expected-note{{add initialization to silence this warning}}
return sizeof(int[len]); // expected-note{{variable 'len' is possibly uninitialized when used here}}
}
|
