2 * Copyright (C) 2013 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 * The plan here is to save all the possible values store to a given struct
22 * We will load all the values in to the function_type_val table first then
23 * run a script on that and load all the resulting values into the type_val
26 * So in this file we want to take the union of everything assigned to the
27 * struct member and insert it into the function_type_val at the end.
29 * You would think that we could use smatch_modification_hooks.c or
30 * extra_modification_hook() here to get the information here but in the end we
31 * need to code everything again a third time.
36 #include "smatch_slist.h"
37 #include "smatch_extra.h"
41 struct stree_stack
*fn_type_val_stack
;
42 struct stree
*fn_type_val
;
43 struct stree
*global_type_val
;
46 static int get_vals(void *unused
, int argc
, char **argv
, char **azColName
)
48 db_vals
= alloc_string(argv
[0]);
52 static void match_inline_start(struct expression
*expr
)
54 push_stree(&fn_type_val_stack
, fn_type_val
);
58 static void match_inline_end(struct expression
*expr
)
60 free_stree(&fn_type_val
);
61 fn_type_val
= pop_stree(&fn_type_val_stack
);
64 int get_db_type_rl(struct expression
*expr
, struct range_list
**rl
)
67 struct range_list
*tmp
;
69 member
= get_member_name(expr
);
74 run_sql(get_vals
, NULL
,
75 "select value from type_value where type = '%s';", member
);
79 str_to_rl(&llong_ctype
, db_vals
, &tmp
);
80 tmp
= cast_rl(get_type(expr
), tmp
);
89 static void add_type_val(char *member
, struct range_list
*rl
)
91 struct smatch_state
*old
, *add
, *new;
93 member
= alloc_string(member
);
94 old
= get_state_stree(fn_type_val
, my_id
, member
, NULL
);
95 add
= alloc_estate_rl(rl
);
97 new = merge_estates(old
, add
);
100 set_state_stree(&fn_type_val
, my_id
, member
, NULL
, new);
103 static void add_fake_type_val(char *member
, struct range_list
*rl
, int ignore
)
105 struct smatch_state
*old
, *add
, *new;
107 member
= alloc_string(member
);
108 old
= get_state_stree(fn_type_val
, my_id
, member
, NULL
);
109 if (old
&& strcmp(old
->name
, "min-max") == 0)
111 if (ignore
&& old
&& strcmp(old
->name
, "ignore") == 0)
113 add
= alloc_estate_rl(rl
);
115 new = merge_estates(old
, add
);
119 new->name
= alloc_string("ignore");
121 new->name
= alloc_string("min-max");
123 set_state_stree(&fn_type_val
, my_id
, member
, NULL
, new);
126 static void add_global_type_val(char *member
, struct range_list
*rl
)
128 struct smatch_state
*old
, *add
, *new;
130 member
= alloc_string(member
);
131 old
= get_state_stree(global_type_val
, my_id
, member
, NULL
);
132 add
= alloc_estate_rl(rl
);
134 new = merge_estates(old
, add
);
137 new = clone_estate_perm(new);
138 set_state_stree_perm(&global_type_val
, my_id
, member
, NULL
, new);
141 static int has_link_cb(void *has_link
, int argc
, char **argv
, char **azColName
)
143 *(int *)has_link
= 1;
146 static int is_ignored_fake_assignment(void)
148 struct expression
*expr
;
153 expr
= get_faked_expression();
154 if (!expr
|| expr
->type
!= EXPR_ASSIGNMENT
)
156 if (!is_void_pointer(expr
->right
))
158 member_name
= get_member_name(expr
->right
);
162 type
= get_type(expr
->left
);
163 if (!type
|| type
->type
!= SYM_PTR
)
165 type
= get_real_base_type(type
);
166 if (!type
|| type
->type
!= SYM_STRUCT
)
169 run_sql(has_link_cb
, &has_link
,
170 "select * from data_info where type = %d and data = '%s' and value = '%s';",
171 TYPE_LINK
, member_name
, type_to_str(type
));
175 static void match_assign_value(struct expression
*expr
)
177 char *member
, *right_member
;
178 struct range_list
*rl
;
181 type
= get_type(expr
->left
);
182 if (type
&& type
->type
== SYM_STRUCT
)
185 member
= get_member_name(expr
->left
);
189 /* if we're saying foo->mtu = bar->mtu then that doesn't add information */
190 right_member
= get_member_name(expr
->right
);
191 if (right_member
&& strcmp(right_member
, member
) == 0)
194 if (is_fake_call(expr
->right
)) {
195 add_fake_type_val(member
, alloc_whole_rl(get_type(expr
->left
)), is_ignored_fake_assignment());
199 if (expr
->op
!= '=') {
200 add_type_val(member
, alloc_whole_rl(get_type(expr
->left
)));
203 get_absolute_rl(expr
->right
, &rl
);
204 rl
= cast_rl(type
, rl
);
205 add_type_val(member
, rl
);
207 free_string(right_member
);
212 * If we too: int *p = &my_struct->member then abandon all hope of tracking
215 static void match_assign_pointer(struct expression
*expr
)
217 struct expression
*right
;
219 struct range_list
*rl
;
222 right
= strip_expr(expr
->right
);
223 if (right
->type
!= EXPR_PREOP
|| right
->op
!= '&')
225 right
= strip_expr(right
->unop
);
227 member
= get_member_name(right
);
230 type
= get_type(right
);
231 rl
= alloc_whole_rl(type
);
232 add_type_val(member
, rl
);
236 static void match_global_assign(struct expression
*expr
)
239 struct range_list
*rl
;
241 member
= get_member_name(expr
->left
);
244 get_absolute_rl(expr
->right
, &rl
);
245 add_global_type_val(member
, rl
);
249 static void unop_expr(struct expression
*expr
)
251 struct range_list
*rl
;
254 if (expr
->op
!= SPECIAL_DECREMENT
&& expr
->op
!= SPECIAL_INCREMENT
)
257 expr
= strip_expr(expr
->unop
);
258 member
= get_member_name(expr
);
261 rl
= alloc_whole_rl(get_type(expr
));
262 add_type_val(member
, rl
);
266 static void asm_expr(struct statement
*stmt
)
268 struct expression
*expr
;
269 struct range_list
*rl
;
273 FOR_EACH_PTR(stmt
->asm_outputs
, expr
) {
275 case 0: /* identifier */
276 case 1: /* constraint */
279 case 2: /* expression */
281 member
= get_member_name(expr
);
284 rl
= alloc_whole_rl(get_type(expr
));
285 add_type_val(member
, rl
);
289 } END_FOR_EACH_PTR(expr
);
292 static void db_param_add(struct expression
*expr
, int param
, char *key
, char *value
)
294 struct expression
*arg
;
296 struct range_list
*rl
;
299 if (strcmp(key
, "*$") != 0)
302 while (expr
->type
== EXPR_ASSIGNMENT
)
303 expr
= strip_expr(expr
->right
);
304 if (expr
->type
!= EXPR_CALL
)
307 arg
= get_argument_from_call_expr(expr
->args
, param
);
308 arg
= strip_expr(arg
);
311 type
= get_member_type_from_key(arg
, key
);
312 if (arg
->type
!= EXPR_PREOP
|| arg
->op
!= '&')
314 arg
= strip_expr(arg
->unop
);
316 member
= get_member_name(arg
);
319 call_results_to_rl(expr
, type
, value
, &rl
);
320 add_type_val(member
, rl
);
324 static void match_end_func_info(struct symbol
*sym
)
328 FOR_EACH_SM(fn_type_val
, sm
) {
329 sql_insert_function_type_value(sm
->name
, sm
->state
->name
);
330 } END_FOR_EACH_SM(sm
);
332 free_stree(&fn_type_val
);
335 static void match_end_file(struct symbol_list
*sym_list
)
339 FOR_EACH_SM(global_type_val
, sm
) {
340 sql_insert_function_type_value(sm
->name
, sm
->state
->name
);
341 } END_FOR_EACH_SM(sm
);
344 void register_type_val(int id
)
351 add_hook(&match_assign_value
, ASSIGNMENT_HOOK
);
352 add_hook(&match_assign_pointer
, ASSIGNMENT_HOOK
);
353 add_hook(&unop_expr
, OP_HOOK
);
354 add_hook(&asm_expr
, ASM_HOOK
);
355 select_return_states_hook(ADDED_VALUE
, &db_param_add
);
357 add_hook(&match_inline_start
, INLINE_FN_START
);
358 add_hook(&match_inline_end
, INLINE_FN_END
);
360 add_hook(&match_end_func_info
, END_FUNC_HOOK
);
362 add_hook(&match_global_assign
, GLOBAL_ASSIGNMENT_HOOK
);
363 add_hook(&match_end_file
, END_FILE_HOOK
);