2 * Copyright (C) 2010 Dan Carpenter.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
19 * smatch_dinfo.c has helper functions for handling data_info structs
30 #include "smatch_slist.h"
31 #include "smatch_extra.h"
33 struct smatch_state
*merge_estates(struct smatch_state
*s1
, struct smatch_state
*s2
)
35 struct smatch_state
*tmp
;
36 struct range_list
*value_ranges
;
37 struct related_list
*rlist
;
40 if (estates_equiv(s1
, s2
))
43 value_ranges
= rl_union(estate_rl(s1
), estate_rl(s2
));
44 tmp
= alloc_estate_rl(value_ranges
);
45 rlist
= get_shared_relations(estate_related(s1
), estate_related(s2
));
46 set_related(tmp
, rlist
);
48 if ((estate_has_hard_max(s1
) && (!estate_rl(s2
) || estate_has_hard_max(s2
))) ||
49 (estate_has_hard_max(s2
) && (!estate_rl(s1
) || estate_has_hard_max(s1
))))
50 estate_set_hard_max(tmp
);
52 estate_set_fuzzy_max(tmp
, sval_max(estate_get_fuzzy_max(s1
), estate_get_fuzzy_max(s2
)));
54 if (estate_capped(s1
) && estate_capped(s2
))
56 if (estate_rl(s1
) && estate_rl(s2
)) {
57 if (estate_capped(s1
) && estate_max(s2
).uvalue
< 100)
59 if (estate_capped(s2
) && estate_max(s1
).uvalue
< 100)
63 estate_set_capped(tmp
);
65 if (estate_treat_untagged(s1
) && estate_treat_untagged(s2
))
66 estate_set_treat_untagged(tmp
);
68 if (estate_assigned(s1
) || estate_assigned(s2
))
69 estate_set_assigned(tmp
);
71 if (estate_new(s1
) || estate_new(s2
))
77 struct data_info
*get_dinfo(struct smatch_state
*state
)
81 return (struct data_info
*)state
->data
;
84 struct range_list
*estate_rl(struct smatch_state
*state
)
88 return get_dinfo(state
)->value_ranges
;
91 struct related_list
*estate_related(struct smatch_state
*state
)
95 return get_dinfo(state
)->related
;
98 sval_t
estate_get_fuzzy_max(struct smatch_state
*state
)
102 if (!state
|| !get_dinfo(state
))
104 return get_dinfo(state
)->fuzzy_max
;
107 int estate_has_fuzzy_max(struct smatch_state
*state
)
109 if (estate_get_fuzzy_max(state
).type
)
114 void estate_set_fuzzy_max(struct smatch_state
*state
, sval_t fuzzy_max
)
116 if (is_ptr_type(estate_type(state
)))
118 if (!rl_has_sval(estate_rl(state
), fuzzy_max
))
120 get_dinfo(state
)->fuzzy_max
= fuzzy_max
;
123 void estate_copy_fuzzy_max(struct smatch_state
*new, struct smatch_state
*old
)
125 if (is_ptr_type(estate_type(new)))
127 if (!estate_has_fuzzy_max(old
))
129 estate_set_fuzzy_max(new, estate_get_fuzzy_max(old
));
132 void estate_clear_fuzzy_max(struct smatch_state
*state
)
136 get_dinfo(state
)->fuzzy_max
= empty
;
139 int estate_has_hard_max(struct smatch_state
*state
)
141 if (!state
|| !estate_rl(state
))
143 return get_dinfo(state
)->hard_max
;
146 void estate_set_hard_max(struct smatch_state
*state
)
148 /* pointers don't have a hard max */
149 if (is_ptr_type(estate_type(state
)))
151 get_dinfo(state
)->hard_max
= 1;
154 void estate_clear_hard_max(struct smatch_state
*state
)
156 get_dinfo(state
)->hard_max
= 0;
159 int estate_get_hard_max(struct smatch_state
*state
, sval_t
*sval
)
161 if (!state
|| !get_dinfo(state
)->hard_max
|| !estate_rl(state
))
163 *sval
= rl_max(estate_rl(state
));
167 bool estate_capped(struct smatch_state
*state
)
171 /* impossible states are capped */
172 if (!estate_rl(state
))
174 return get_dinfo(state
)->capped
;
177 void estate_set_capped(struct smatch_state
*state
)
179 get_dinfo(state
)->capped
= true;
182 bool estate_treat_untagged(struct smatch_state
*state
)
187 /* impossible states are capped */
188 if (!estate_rl(state
))
191 return get_dinfo(state
)->treat_untagged
;
194 void estate_set_treat_untagged(struct smatch_state
*state
)
196 get_dinfo(state
)->treat_untagged
= true;
199 bool estate_assigned(struct smatch_state
*state
)
201 if (!estate_rl(state
))
203 return get_dinfo(state
)->assigned
;
206 void estate_set_assigned(struct smatch_state
*state
)
208 get_dinfo(state
)->assigned
= true;
211 bool estate_new(struct smatch_state
*state
)
213 if (!estate_rl(state
))
215 return get_dinfo(state
)->set
;
218 void estate_set_new(struct smatch_state
*state
)
220 get_dinfo(state
)->set
= true;
223 sval_t
estate_min(struct smatch_state
*state
)
225 return rl_min(estate_rl(state
));
228 sval_t
estate_max(struct smatch_state
*state
)
230 return rl_max(estate_rl(state
));
233 struct symbol
*estate_type(struct smatch_state
*state
)
235 return rl_max(estate_rl(state
)).type
;
238 static int rlists_equiv(struct related_list
*one
, struct related_list
*two
)
240 struct relation
*one_rel
;
241 struct relation
*two_rel
;
243 PREPARE_PTR_LIST(one
, one_rel
);
244 PREPARE_PTR_LIST(two
, two_rel
);
246 if (!one_rel
&& !two_rel
)
248 if (!one_rel
|| !two_rel
)
250 if (one_rel
->sym
!= two_rel
->sym
)
252 if (strcmp(one_rel
->name
, two_rel
->name
))
254 NEXT_PTR_LIST(one_rel
);
255 NEXT_PTR_LIST(two_rel
);
257 FINISH_PTR_LIST(two_rel
);
258 FINISH_PTR_LIST(one_rel
);
263 int estates_equiv(struct smatch_state
*one
, struct smatch_state
*two
)
269 if (!rlists_equiv(estate_related(one
), estate_related(two
)))
271 if (estate_capped(one
) != estate_capped(two
))
273 if (estate_treat_untagged(one
) != estate_treat_untagged(two
))
275 if (estate_has_hard_max(one
) != estate_has_hard_max(two
))
277 if (estate_new(one
) != estate_new(two
))
279 if (strcmp(one
->name
, two
->name
) == 0)
284 int estate_is_whole(struct smatch_state
*state
)
286 return is_whole_rl(estate_rl(state
));
289 int estate_is_empty(struct smatch_state
*state
)
291 return state
&& !estate_rl(state
);
294 int estate_is_unknown(struct smatch_state
*state
)
296 if (!estate_is_whole(state
))
298 if (estate_related(state
))
300 if (estate_has_fuzzy_max(state
))
305 int estate_get_single_value(struct smatch_state
*state
, sval_t
*sval
)
309 if (!estate_rl(state
))
311 min
= rl_min(estate_rl(state
));
312 max
= rl_max(estate_rl(state
));
313 if (sval_cmp(min
, max
) != 0)
319 static struct data_info
*alloc_dinfo(void)
321 struct data_info
*ret
;
323 ret
= __alloc_data_info(0);
324 memset(ret
, 0, sizeof(*ret
));
328 static struct data_info
*alloc_dinfo_range(sval_t min
, sval_t max
)
330 struct data_info
*ret
;
333 add_range(&ret
->value_ranges
, min
, max
);
337 static struct data_info
*alloc_dinfo_range_list(struct range_list
*rl
)
339 struct data_info
*ret
;
342 ret
->value_ranges
= rl
;
346 static struct data_info
*clone_dinfo(struct data_info
*dinfo
)
348 struct data_info
*ret
;
351 ret
->related
= clone_related_list(dinfo
->related
);
352 ret
->value_ranges
= clone_rl(dinfo
->value_ranges
);
353 ret
->hard_max
= dinfo
->hard_max
;
354 ret
->fuzzy_max
= dinfo
->fuzzy_max
;
358 struct smatch_state
*clone_estate(struct smatch_state
*state
)
360 struct smatch_state
*ret
;
365 ret
= __alloc_smatch_state(0);
366 ret
->name
= state
->name
;
367 ret
->data
= clone_dinfo(get_dinfo(state
));
371 struct smatch_state
*clone_partial_estate(struct smatch_state
*state
, struct range_list
*rl
)
373 struct smatch_state
*ret
;
378 rl
= cast_rl(estate_type(state
), rl
);
380 ret
= alloc_estate_rl(rl
);
381 set_related(ret
, clone_related_list(estate_related(state
)));
382 if (estate_has_hard_max(state
))
383 estate_set_hard_max(ret
);
384 if (estate_has_fuzzy_max(state
))
385 estate_set_fuzzy_max(ret
, estate_get_fuzzy_max(state
));
390 struct smatch_state
*alloc_estate_empty(void)
392 struct smatch_state
*state
;
393 struct data_info
*dinfo
;
395 dinfo
= alloc_dinfo();
396 state
= __alloc_smatch_state(0);
402 struct smatch_state
*alloc_estate_whole(struct symbol
*type
)
404 return alloc_estate_rl(alloc_whole_rl(type
));
407 struct smatch_state
*extra_empty(void)
409 struct smatch_state
*ret
;
411 ret
= __alloc_smatch_state(0);
413 ret
->data
= alloc_dinfo();
417 struct smatch_state
*alloc_estate_sval(sval_t sval
)
419 struct smatch_state
*state
;
421 state
= __alloc_smatch_state(0);
422 state
->data
= alloc_dinfo_range(sval
, sval
);
423 state
->name
= show_rl(get_dinfo(state
)->value_ranges
);
424 estate_set_hard_max(state
);
425 estate_set_fuzzy_max(state
, sval
);
429 struct smatch_state
*alloc_estate_range(sval_t min
, sval_t max
)
431 struct smatch_state
*state
;
433 state
= __alloc_smatch_state(0);
434 state
->data
= alloc_dinfo_range(min
, max
);
435 state
->name
= show_rl(get_dinfo(state
)->value_ranges
);
439 struct smatch_state
*alloc_estate_rl(struct range_list
*rl
)
441 struct smatch_state
*state
;
444 return extra_empty();
446 state
= __alloc_smatch_state(0);
447 state
->data
= alloc_dinfo_range_list(rl
);
448 state
->name
= show_rl(rl
);
452 struct smatch_state
*clone_estate_cast(struct symbol
*type
, struct smatch_state
*state
)
454 struct smatch_state
*ret
;
455 struct data_info
*dinfo
;
460 dinfo
= alloc_dinfo();
461 dinfo
->value_ranges
= clone_rl(cast_rl(type
, estate_rl(state
)));
463 ret
= __alloc_smatch_state(0);
464 ret
->name
= show_rl(dinfo
->value_ranges
);
470 struct smatch_state
*get_implied_estate(struct expression
*expr
)
472 struct smatch_state
*state
;
473 struct range_list
*rl
;
475 state
= get_state_expr(SMATCH_EXTRA
, expr
);
478 if (!get_implied_rl(expr
, &rl
))
479 rl
= alloc_whole_rl(get_type(expr
));
480 return alloc_estate_rl(rl
);
484 * One of the complications is that smatch tries to free a bunch of data at the
485 * end of every function.
487 struct data_info
*clone_dinfo_perm(struct data_info
*dinfo
)
489 struct data_info
*ret
;
491 ret
= malloc(sizeof(*ret
));
492 memset(ret
, 0, sizeof(*ret
));
494 ret
->value_ranges
= clone_rl_permanent(dinfo
->value_ranges
);
496 ret
->fuzzy_max
= dinfo
->fuzzy_max
;
500 struct smatch_state
*clone_estate_perm(struct smatch_state
*state
)
502 struct smatch_state
*ret
;
504 ret
= malloc(sizeof(*ret
));
505 ret
->name
= alloc_string(state
->name
);
506 ret
->data
= clone_dinfo_perm(get_dinfo(state
));