2 * Copyright (C) 2012 Oracle.
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 * This is almost the same as smatch_param_filter.c. The difference is that
20 * this only deals with values passed on the stack and param filter only deals
21 * with values changed so that the caller sees the new value. It other words
22 * the key for these should always be "$" and the key for param_filter should
23 * never be "$". Also smatch_param_set() should never use "$" as the key.
24 * Param set should work together with param_filter to determine the value that
25 * the caller sees at the end.
27 * This is for functions like this:
31 * if (a >= 0 && a < 10) {
38 * If we pass in 5, it returns 1.
40 * It's a bit complicated because we can't just consider the final value, we
41 * have to always consider the passed in value.
47 #include "smatch_extra.h"
48 #include "smatch_slist.h"
52 static struct smatch_state
*unmatched_state(struct sm_state
*sm
)
54 struct smatch_state
*state
;
56 state
= __get_state(SMATCH_EXTRA
, sm
->name
, sm
->sym
);
59 return alloc_estate_whole(estate_type(sm
->state
));
62 struct smatch_state
*get_orig_estate(const char *name
, struct symbol
*sym
)
64 struct smatch_state
*state
;
66 state
= get_state(my_id
, name
, sym
);
70 state
= get_state(SMATCH_EXTRA
, name
, sym
);
73 return alloc_estate_rl(alloc_whole_rl(get_real_base_type(sym
)));
76 struct smatch_state
*get_orig_estate_type(const char *name
, struct symbol
*sym
, struct symbol
*type
)
78 struct smatch_state
*state
;
80 state
= get_state(my_id
, name
, sym
);
84 state
= get_state(SMATCH_EXTRA
, name
, sym
);
87 return alloc_estate_rl(alloc_whole_rl(type
));
90 static struct range_list
*generify_mtag_range(struct smatch_state
*state
)
92 struct range_list
*rl
;
93 struct data_range
*drange
;
95 if (!estate_type(state
) || estate_type(state
)->type
!= SYM_PTR
)
96 return estate_rl(state
);
99 * The problem is that we get too specific on our param limits when we
100 * know exactly what pointers are passed to a function. It gets to the
101 * point where we say "pointer x will succeed, but everything else will
102 * fail." And then we introduce a new caller which passes a different
103 * pointer and it's like, "Sorry bro, that's not possible."
106 rl
= estate_rl(state
);
107 FOR_EACH_PTR(rl
, drange
) {
108 if (drange
->min
.value
!= drange
->max
.value
)
110 if (drange
->min
.value
== 0)
112 if (is_err_ptr(drange
->min
))
114 return rl_union(valid_ptr_rl
, rl
);
115 } END_FOR_EACH_PTR(drange
);
117 return estate_rl(state
);
120 static void print_return_value_param(int return_id
, char *return_ranges
, struct expression
*expr
)
122 struct smatch_state
*state
, *old
;
123 struct sm_state
*tmp
;
124 struct range_list
*rl
;
125 const char *param_name
;
128 FOR_EACH_MY_SM(SMATCH_EXTRA
, __get_cur_stree(), tmp
) {
129 param
= get_param_num_from_sym(tmp
->sym
);
133 param_name
= get_param_name(tmp
);
137 state
= __get_state(my_id
, tmp
->name
, tmp
->sym
);
141 if (estate_is_whole(state
) || estate_is_empty(state
))
143 old
= get_state_stree(get_start_states(), SMATCH_EXTRA
, tmp
->name
, tmp
->sym
);
144 if (old
&& rl_equiv(estate_rl(old
), estate_rl(state
)))
147 if (is_ignored_kernel_data(param_name
))
150 rl
= generify_mtag_range(state
);
151 sql_insert_return_states(return_id
, return_ranges
, PARAM_LIMIT
,
152 param
, param_name
, show_rl(rl
));
153 } END_FOR_EACH_SM(tmp
);
156 static void extra_mod_hook(const char *name
, struct symbol
*sym
, struct expression
*expr
, struct smatch_state
*state
)
158 struct smatch_state
*orig_vals
;
161 param
= get_param_num_from_sym(sym
);
165 orig_vals
= get_orig_estate_type(name
, sym
, estate_type(state
));
166 set_state(my_id
, name
, sym
, orig_vals
);
169 void register_param_limit(int id
)
173 set_dynamic_states(my_id
);
175 add_extra_mod_hook(&extra_mod_hook
);
176 add_unmatched_state_hook(my_id
, &unmatched_state
);
177 add_merge_hook(my_id
, &merge_estates
);
179 add_split_return_callback(&print_return_value_param
);