Clang Project

clang_source_code/test/Analysis/diagnostics/no-store-func-path-notes.c
1// RUN: %clang_analyze_cc1 -x c -analyzer-checker=core -analyzer-output=text -verify %s
2
3typedef __typeof(sizeof(int)) size_t;
4void *memset(void *__s, int __c, size_t __n);
5
6int initializer1(int *p, int x) {
7  if (x) { // expected-note{{Taking false branch}}
8    *p = 1;
9    return 0;
10  } else {
11    return 1; // expected-note {{Returning without writing to '*p'}}
12  }
13}
14
15int param_not_initialized_by_func() {
16  int p; // expected-note {{'p' declared without an initial value}}
17  int out = initializer1(&p, 0); // expected-note{{Calling 'initializer1'}}
18                                 // expected-note@-1{{Returning from 'initializer1'}}
19  return p; // expected-note{{Undefined or garbage value returned to caller}}
20            // expected-warning@-1{{Undefined or garbage value returned to caller}}
21}
22
23int param_initialized_properly() {
24  int p;
25  int out = initializer1(&p, 1);
26  return p; //no-warning
27}
28
29static int global;
30
31int initializer2(int **p, int x) {
32  if (x) { // expected-note{{Taking false branch}}
33    *p = &global;
34    return 0;
35  } else {
36    return 1; // expected-note {{Returning without writing to '*p'}}
37  }
38}
39
40int param_not_written_into_by_func() {
41  int *p = 0;                    // expected-note{{'p' initialized to a null pointer value}}
42  int out = initializer2(&p, 0); // expected-note{{Calling 'initializer2'}}
43                                 // expected-note@-1{{Returning from 'initializer2'}}
44  return *p;                     // expected-warning{{Dereference of null pointer (loaded from variable 'p')}}
45                                 // expected-note@-1{{Dereference of null pointer (loaded from variable 'p')}}
46}
47
48void initializer3(int *p, int param) {
49  if (param) // expected-note{{Taking false branch}}
50    *p = 0;
51} // expected-note{{Returning without writing to '*p'}}
52
53int param_written_into_by_void_func() {
54  int p;               // expected-note{{'p' declared without an initial value}}
55  initializer3(&p, 0); // expected-note{{Calling 'initializer3'}}
56                       // expected-note@-1{{Returning from 'initializer3'}}
57  return p;            // expected-warning{{Undefined or garbage value returned to caller}}
58                       // expected-note@-1{{Undefined or garbage value returned to caller}}
59}
60
61void initializer4(int *p, int param) {
62  if (param) // expected-note{{Taking false branch}}
63    *p = 0;
64} // expected-note{{Returning without writing to '*p'}}
65
66void initializer5(int *p, int param) {
67  if (!param) // expected-note{{Taking false branch}}
68    *p = 0;
69} // expected-note{{Returning without writing to '*p'}}
70
71int multi_init_tries_func() {
72  int p;               // expected-note{{'p' declared without an initial value}}
73  initializer4(&p, 0); // expected-note{{Calling 'initializer4'}}
74                       // expected-note@-1{{Returning from 'initializer4'}}
75  initializer5(&p, 1); // expected-note{{Calling 'initializer5'}}
76                       // expected-note@-1{{Returning from 'initializer5'}}
77  return p;            // expected-warning{{Undefined or garbage value returned to caller}}
78                       // expected-note@-1{{Undefined or garbage value returned to caller}}
79}
80
81int initializer6(const int *p) {
82  return 0;
83}
84
85int no_msg_on_const() {
86  int p; // expected-note{{'p' declared without an initial value}}
87  initializer6(&p);
88  return p; // expected-warning{{Undefined or garbage value returned to caller}}
89            // expected-note@-1{{Undefined or garbage value returned to caller}}
90}
91
92typedef struct {
93  int x;
94} S;
95
96int initializer7(S *s, int param) {
97  if (param) { // expected-note{{Taking false branch}}
98    s->x = 0;
99    return 0;
100  }
101  return 1; // expected-note{{Returning without writing to 's->x'}}
102}
103
104int initialize_struct_field() {
105  S local;
106  initializer7(&local, 0); // expected-note{{Calling 'initializer7'}}
107                           // expected-note@-1{{Returning from 'initializer7'}}
108  return local.x;          // expected-warning{{Undefined or garbage value returned to caller}}
109                           // expected-note@-1{{Undefined or garbage value returned to caller}}
110}
111
112void nullwriter(int **p) {
113  *p = 0; // expected-note{{Null pointer value stored to 'p'}}
114} // no extra note
115
116int usage() {
117  int x = 0;
118  int *p = &x;
119  nullwriter(&p); // expected-note{{Calling 'nullwriter'}}
120                  // expected-note@-1{{Returning from 'nullwriter'}}
121  return *p;      // expected-warning{{Dereference of null pointer (loaded from variable 'p')}}
122                  // expected-note@-1{{Dereference of null pointer (loaded from variable 'p')}}
123}
124
125typedef struct {
126  int x;
127  int y;
128} A;
129
130void partial_initializer(A *a) {
131  a->x = 0;
132} // expected-note{{Returning without writing to 'a->y'}}
133
134int use_partial_initializer() {
135  A a;
136  partial_initializer(&a); // expected-note{{Calling 'partial_initializer'}}
137                           // expected-note@-1{{Returning from 'partial_initializer'}}
138  return a.y;              // expected-warning{{Undefined or garbage value returned to caller}}
139                           // expected-note@-1{{Undefined or garbage value returned to caller}}
140}
141
142typedef struct {
143  int x;
144  int y;
145} B;
146
147typedef struct {
148  B b;
149} C;
150
151void partial_nested_initializer(C *c) {
152  c->b.x = 0;
153} // expected-note{{Returning without writing to 'c->b.y'}}
154
155int use_partial_nested_initializer() {
156  B localB;
157  C localC;
158  localC.b = localB;
159  partial_nested_initializer(&localC); // expected-note{{Calling 'partial_nested_initializer'}}
160                                       // expected-note@-1{{Returning from 'partial_nested_initializer'}}
161  return localC.b.y;                   // expected-warning{{Undefined or garbage value returned to caller}}
162                                       // expected-note@-1{{Undefined or garbage value returned to caller}}
163}
164
165void test_subregion_assignment(C* c) {
166  B b;
167  c->b = b;
168}
169
170int use_subregion_assignment() {
171  C c;
172  test_subregion_assignment(&c); // expected-note{{Calling 'test_subregion_assignment'}}
173                                 // expected-note@-1{{Returning from 'test_subregion_assignment'}}
174  return c.b.x; // expected-warning{{Undefined or garbage value returned to caller}}
175                // expected-note@-1{{Undefined or garbage value returned to caller}}
176}
177
178int confusing_signature(int *);
179int confusing_signature(int *p) {
180  return 0; // expected-note{{Returning without writing to '*p'}}
181}
182
183int use_confusing_signature() {
184  int a; // expected-note {{'a' declared without an initial value}}
185  confusing_signature(&a); // expected-note{{Calling 'confusing_signature'}}
186                           // expected-note@-1{{Returning from 'confusing_signature'}}
187  return a; // expected-note{{Undefined or garbage value returned to caller}}
188            // expected-warning@-1{{Undefined or garbage value returned to caller}}
189}
190
191int coin();
192
193int multiindirection(int **p) {
194  if (coin()) // expected-note{{Assuming the condition is true}}
195              // expected-note@-1{{Taking true branch}}
196    return 1; // expected-note{{Returning without writing to '**p'}}
197  *(*p) = 0;
198  return 0;
199}
200
201int usemultiindirection() {
202  int a; // expected-note {{'a' declared without an initial value}}
203  int *b = &a;
204  multiindirection(&b); // expected-note{{Calling 'multiindirection'}}
205                        // expected-note@-1{{Returning from 'multiindirection'}}
206  return a; // expected-note{{Undefined or garbage value returned to caller}}
207            // expected-warning@-1{{Undefined or garbage value returned to caller}}
208}
209
210int indirectingstruct(S** s) {
211  if (coin()) // expected-note{{Assuming the condition is true}}
212              // expected-note@-1{{Taking true branch}}
213    return 1; // expected-note{{Returning without writing to '(*s)->x'}}
214
215  (*s)->x = 0;
216  return 0;
217}
218
219int useindirectingstruct() {
220  S s;
221  S* p = &s;
222  indirectingstruct(&p); //expected-note{{Calling 'indirectingstruct'}}
223                         //expected-note@-1{{Returning from 'indirectingstruct'}}
224  return s.x; // expected-warning{{Undefined or garbage value returned to caller}}
225              // expected-note@-1{{Undefined or garbage value returned to caller}}
226}
227
228typedef struct {
229  int *x;
230} D;
231
232void initializeMaybeInStruct(D* pD) {
233  if (coin()) // expected-note{{Assuming the condition is false}}
234              // expected-note@-1{{Taking false branch}}
235    *pD->x = 120;
236} // expected-note{{Returning without writing to 'pD->x'}}
237
238int useInitializeMaybeInStruct() {
239  int z; // expected-note{{'z' declared without an initial value}}
240  D d;
241  d.x = &z;
242  initializeMaybeInStruct(&d); // expected-note{{Calling 'initializeMaybeInStruct'}}
243                               // expected-note@-1{{Returning from 'initializeMaybeInStruct'}}
244  return z; // expected-warning{{Undefined or garbage value returned to caller}}
245            // expected-note@-1{{Undefined or garbage value returned to caller}}
246}
247
CodeThinker, Enjoy your reading code