build_kernel_data.sh: error out if the right packages aren't installed
[smatch.git] / smatch_estate.c
blob701dafd5a1f2e6c4882adbedae0ba74bde650546
1 /*
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
23 #include <stdlib.h>
24 #ifndef __USE_ISOC99
25 #define __USE_ISOC99
26 #endif
27 #include <limits.h>
28 #include "parse.h"
29 #include "smatch.h"
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;
39 if (estates_equiv(s1, s2))
40 return s1;
42 value_ranges = rl_union(estate_rl(s1), estate_rl(s2));
43 tmp = alloc_estate_rl(value_ranges);
44 rlist = get_shared_relations(estate_related(s1), estate_related(s2));
45 set_related(tmp, rlist);
46 if (estate_has_hard_max(s1) && estate_has_hard_max(s2))
47 estate_set_hard_max(tmp);
49 estate_set_fuzzy_max(tmp, sval_max(estate_get_fuzzy_max(s1), estate_get_fuzzy_max(s2)));
51 return tmp;
54 struct data_info *get_dinfo(struct smatch_state *state)
56 if (!state)
57 return NULL;
58 return (struct data_info *)state->data;
61 struct range_list *estate_rl(struct smatch_state *state)
63 if (!state)
64 return NULL;
65 return get_dinfo(state)->value_ranges;
68 struct related_list *estate_related(struct smatch_state *state)
70 if (!state)
71 return NULL;
72 return get_dinfo(state)->related;
75 sval_t estate_get_fuzzy_max(struct smatch_state *state)
77 sval_t empty = {};
79 if (!state || !get_dinfo(state))
80 return empty;
81 return get_dinfo(state)->fuzzy_max;
84 int estate_has_fuzzy_max(struct smatch_state *state)
86 if (estate_get_fuzzy_max(state).type)
87 return 1;
88 return 0;
91 void estate_set_fuzzy_max(struct smatch_state *state, sval_t fuzzy_max)
93 if (!rl_has_sval(estate_rl(state), fuzzy_max))
94 return;
95 get_dinfo(state)->fuzzy_max = fuzzy_max;
98 void estate_copy_fuzzy_max(struct smatch_state *new, struct smatch_state *old)
100 if (!estate_has_fuzzy_max(old))
101 return;
102 estate_set_fuzzy_max(new, estate_get_fuzzy_max(old));
105 void estate_clear_fuzzy_max(struct smatch_state *state)
107 sval_t empty = {};
109 get_dinfo(state)->fuzzy_max = empty;
112 int estate_has_hard_max(struct smatch_state *state)
114 if (!state)
115 return 0;
116 return get_dinfo(state)->hard_max;
119 void estate_set_hard_max(struct smatch_state *state)
121 get_dinfo(state)->hard_max = 1;
124 void estate_clear_hard_max(struct smatch_state *state)
126 get_dinfo(state)->hard_max = 0;
129 int estate_get_hard_max(struct smatch_state *state, sval_t *sval)
131 if (!state || !get_dinfo(state)->hard_max || !estate_rl(state))
132 return 0;
133 *sval = rl_max(estate_rl(state));
134 return 1;
137 sval_t estate_min(struct smatch_state *state)
139 return rl_min(estate_rl(state));
142 sval_t estate_max(struct smatch_state *state)
144 return rl_max(estate_rl(state));
147 struct symbol *estate_type(struct smatch_state *state)
149 return rl_max(estate_rl(state)).type;
152 static int rlists_equiv(struct related_list *one, struct related_list *two)
154 struct relation *one_rel;
155 struct relation *two_rel;
157 PREPARE_PTR_LIST(one, one_rel);
158 PREPARE_PTR_LIST(two, two_rel);
159 for (;;) {
160 if (!one_rel && !two_rel)
161 return 1;
162 if (!one_rel || !two_rel)
163 return 0;
164 if (one_rel->sym != two_rel->sym)
165 return 0;
166 if (strcmp(one_rel->name, two_rel->name))
167 return 0;
168 NEXT_PTR_LIST(one_rel);
169 NEXT_PTR_LIST(two_rel);
171 FINISH_PTR_LIST(two_rel);
172 FINISH_PTR_LIST(one_rel);
174 return 1;
177 int estates_equiv(struct smatch_state *one, struct smatch_state *two)
179 if (one == two)
180 return 1;
181 if (!rlists_equiv(estate_related(one), estate_related(two)))
182 return 0;
183 if (strcmp(one->name, two->name) == 0)
184 return 1;
185 return 0;
188 int estate_is_whole(struct smatch_state *state)
190 return is_whole_rl(estate_rl(state));
193 int estate_get_single_value(struct smatch_state *state, sval_t *sval)
195 sval_t min, max;
197 min = rl_min(estate_rl(state));
198 max = rl_max(estate_rl(state));
199 if (sval_cmp(min, max) != 0)
200 return 0;
201 *sval = min;
202 return 1;
205 static struct data_info *alloc_dinfo(void)
207 struct data_info *ret;
209 ret = __alloc_data_info(0);
210 memset(ret, 0, sizeof(*ret));
211 return ret;
214 static struct data_info *alloc_dinfo_range(sval_t min, sval_t max)
216 struct data_info *ret;
218 ret = alloc_dinfo();
219 add_range(&ret->value_ranges, min, max);
220 return ret;
223 static struct data_info *alloc_dinfo_range_list(struct range_list *rl)
225 struct data_info *ret;
227 ret = alloc_dinfo();
228 ret->value_ranges = rl;
229 return ret;
232 static struct data_info *clone_dinfo(struct data_info *dinfo)
234 struct data_info *ret;
236 ret = alloc_dinfo();
237 ret->related = clone_related_list(dinfo->related);
238 ret->value_ranges = clone_rl(dinfo->value_ranges);
239 ret->hard_max = dinfo->hard_max;
240 ret->fuzzy_max = dinfo->fuzzy_max;
241 return ret;
244 struct smatch_state *clone_estate(struct smatch_state *state)
246 struct smatch_state *ret;
248 ret = __alloc_smatch_state(0);
249 ret->name = state->name;
250 ret->data = clone_dinfo(get_dinfo(state));
251 return ret;
254 struct smatch_state *alloc_estate_empty(void)
256 struct smatch_state *state;
257 struct data_info *dinfo;
259 dinfo = alloc_dinfo();
260 state = __alloc_smatch_state(0);
261 state->data = dinfo;
262 state->name = "";
263 return state;
266 struct smatch_state *alloc_estate_whole(struct symbol *type)
268 return alloc_estate_rl(alloc_whole_rl(type));
271 struct smatch_state *extra_empty(void)
273 struct smatch_state *ret;
275 ret = __alloc_smatch_state(0);
276 ret->name = "empty";
277 ret->data = alloc_dinfo();
278 return ret;
281 struct smatch_state *alloc_estate_sval(sval_t sval)
283 struct smatch_state *state;
285 state = __alloc_smatch_state(0);
286 state->data = alloc_dinfo_range(sval, sval);
287 state->name = show_rl(get_dinfo(state)->value_ranges);
288 estate_set_hard_max(state);
289 estate_set_fuzzy_max(state, sval);
290 return state;
293 struct smatch_state *alloc_estate_range(sval_t min, sval_t max)
295 struct smatch_state *state;
297 state = __alloc_smatch_state(0);
298 state->data = alloc_dinfo_range(min, max);
299 state->name = show_rl(get_dinfo(state)->value_ranges);
300 return state;
303 struct smatch_state *alloc_estate_rl(struct range_list *rl)
305 struct smatch_state *state;
307 if (!rl)
308 return extra_empty();
310 state = __alloc_smatch_state(0);
311 state->data = alloc_dinfo_range_list(rl);
312 state->name = show_rl(rl);
313 return state;
316 struct smatch_state *get_implied_estate(struct expression *expr)
318 struct smatch_state *state;
319 struct range_list *rl;
321 state = get_state_expr(SMATCH_EXTRA, expr);
322 if (state)
323 return state;
324 if (!get_implied_rl(expr, &rl))
325 rl = alloc_whole_rl(get_type(expr));
326 return alloc_estate_rl(rl);
329 struct smatch_state *estate_filter_range(struct smatch_state *orig,
330 sval_t filter_min, sval_t filter_max)
332 struct range_list *rl;
333 struct smatch_state *state;
335 if (!orig)
336 orig = alloc_estate_whole(filter_min.type);
338 rl = remove_range(estate_rl(orig), filter_min, filter_max);
339 state = alloc_estate_rl(rl);
340 if (estate_has_hard_max(orig))
341 estate_set_hard_max(state);
342 if (estate_has_fuzzy_max(orig))
343 estate_set_fuzzy_max(state, estate_get_fuzzy_max(orig));
344 return state;
347 struct smatch_state *estate_filter_sval(struct smatch_state *orig, sval_t sval)
349 return estate_filter_range(orig, sval, sval);
353 * One of the complications is that smatch tries to free a bunch of data at the
354 * end of every function.
356 struct data_info *clone_dinfo_perm(struct data_info *dinfo)
358 struct data_info *ret;
360 ret = malloc(sizeof(*ret));
361 ret->related = NULL;
362 ret->value_ranges = clone_rl_permanent(dinfo->value_ranges);
363 ret->hard_max = 0;
364 ret->fuzzy_max = dinfo->fuzzy_max;
365 return ret;
368 struct smatch_state *clone_estate_perm(struct smatch_state *state)
370 struct smatch_state *ret;
372 ret = malloc(sizeof(*ret));
373 ret->name = alloc_string(state->name);
374 ret->data = clone_dinfo_perm(get_dinfo(state));
375 return ret;