From 4da05e8047efaf93c56ca291471c7b0f73be0a2a Mon Sep 17 00:00:00 2001 From: Dan Carpenter Date: Mon, 24 Feb 2014 23:50:15 +0300 Subject: [PATCH] states, stree: make a bunch of the public API use stree instead slist This is sort of a mixed up too ambitious and not complete change. It was getting too big for one change so I just shimmed the rest off. Fortunately I can just grep for stree_to_slist() to find out where to continue. Signed-off-by: Dan Carpenter --- smatch.h | 10 ++--- smatch_conditions.c | 87 +++++++++++++++++++------------------- smatch_db.c | 12 +++--- smatch_extra.c | 2 +- smatch_flow.c | 2 +- smatch_function_hooks.c | 108 ++++++++++++++++++++++++------------------------ smatch_implied.c | 2 +- smatch_states.c | 20 ++++----- 8 files changed, 121 insertions(+), 122 deletions(-) diff --git a/smatch.h b/smatch.h index f7278366..e135b5b6 100644 --- a/smatch.h +++ b/smatch.h @@ -453,7 +453,7 @@ int get_db_type_rl(struct expression *expr, struct range_list **rl); /* smatch_states.c */ void __push_fake_cur_slist(); -struct state_list *__pop_fake_cur_slist(); +struct AVL *__pop_fake_cur_slist(); void __free_fake_cur_slist(); void __set_fake_cur_slist_fast(struct state_list *slist); void __pop_fake_cur_slist_fast(void); @@ -490,10 +490,10 @@ void __use_pre_cond_states(void); void __use_cond_true_states(void); void __use_cond_false_states(void); void __push_cond_stacks(void); -struct state_list *__copy_cond_true_states(void); -struct state_list *__copy_cond_false_states(void); -struct state_list *__pop_cond_true_stack(void); -struct state_list *__pop_cond_false_stack(void); +struct AVL *__copy_cond_true_states(void); +struct AVL *__copy_cond_false_states(void); +struct AVL *__pop_cond_true_stack(void); +struct AVL *__pop_cond_false_stack(void); void __and_cond_states(void); void __or_cond_states(void); void __save_pre_cond_states(void); diff --git a/smatch_conditions.c b/smatch_conditions.c index 9073ad8a..f4150cf5 100644 --- a/smatch_conditions.c +++ b/smatch_conditions.c @@ -190,15 +190,14 @@ static void handle_logical(struct expression *expr) __use_cond_true_states(); } -static struct state_list *combine(struct state_list *orig, struct state_list *fake, - struct state_list *new) +static struct AVL *combine_strees(struct AVL *orig, struct AVL *fake, struct AVL *new) { - struct state_list *ret = NULL; + struct AVL *ret = NULL; - overwrite_slist(orig, &ret); - overwrite_slist(fake, &ret); - overwrite_slist(new, &ret); - free_slist(&new); + overwrite_stree(orig, &ret); + overwrite_stree(fake, &ret); + overwrite_stree(new, &ret); + free_stree(&new); return ret; } @@ -216,14 +215,14 @@ static struct state_list *combine(struct state_list *orig, struct state_list *fa static void handle_select(struct expression *expr) { - struct state_list *a_T = NULL; - struct state_list *a_F = NULL; - struct state_list *a_T_b_T = NULL; - struct state_list *a_T_b_F = NULL; - struct state_list *a_T_b_fake = NULL; - struct state_list *a_F_c_T = NULL; - struct state_list *a_F_c_F = NULL; - struct state_list *a_F_c_fake = NULL; + struct AVL *a_T = NULL; + struct AVL *a_F = NULL; + struct AVL *a_T_b_T = NULL; + struct AVL *a_T_b_F = NULL; + struct AVL *a_T_b_fake = NULL; + struct AVL *a_F_c_T = NULL; + struct AVL *a_F_c_F = NULL; + struct AVL *a_F_c_fake = NULL; struct sm_state *sm; /* @@ -266,8 +265,8 @@ static void handle_select(struct expression *expr) split_conditions(expr->cond_true); __process_post_op_stack(); a_T_b_fake = __pop_fake_cur_slist(); - a_T_b_T = combine(a_T, a_T_b_fake, __pop_cond_true_stack()); - a_T_b_F = combine(a_T, a_T_b_fake, __pop_cond_false_stack()); + a_T_b_T = combine_strees(a_T, a_T_b_fake, __pop_cond_true_stack()); + a_T_b_F = combine_strees(a_T, a_T_b_fake, __pop_cond_false_stack()); __use_cond_false_states(); @@ -275,53 +274,53 @@ static void handle_select(struct expression *expr) __push_fake_cur_slist(); split_conditions(expr->cond_false); a_F_c_fake = __pop_fake_cur_slist(); - a_F_c_T = combine(a_F, a_F_c_fake, __pop_cond_true_stack()); - a_F_c_F = combine(a_F, a_F_c_fake, __pop_cond_false_stack()); + a_F_c_T = combine_strees(a_F, a_F_c_fake, __pop_cond_true_stack()); + a_F_c_F = combine_strees(a_F, a_F_c_fake, __pop_cond_false_stack()); /* We have to restore the pre condition states so that - implied_condition_true() will use the right cur_slist */ + implied_condition_true() will use the right cur_stree */ __use_pre_cond_states(); if (implied_condition_true(expr->cond_true)) { - free_slist(&a_T_b_T); - free_slist(&a_T_b_F); - a_T_b_T = clone_slist(a_T); - overwrite_slist(a_T_b_fake, &a_T_b_T); + free_stree(&a_T_b_T); + free_stree(&a_T_b_F); + a_T_b_T = clone_stree(a_T); + overwrite_stree(a_T_b_fake, &a_T_b_T); } if (implied_condition_false(expr->cond_true)) { - free_slist(&a_T_b_T); - free_slist(&a_T_b_F); - a_T_b_F = clone_slist(a_T); - overwrite_slist(a_T_b_fake, &a_T_b_F); + free_stree(&a_T_b_T); + free_stree(&a_T_b_F); + a_T_b_F = clone_stree(a_T); + overwrite_stree(a_T_b_fake, &a_T_b_F); } if (implied_condition_true(expr->cond_false)) { - free_slist(&a_F_c_T); - free_slist(&a_F_c_F); - a_F_c_T = clone_slist(a_F); - overwrite_slist(a_F_c_fake, &a_F_c_T); + free_stree(&a_F_c_T); + free_stree(&a_F_c_F); + a_F_c_T = clone_stree(a_F); + overwrite_stree(a_F_c_fake, &a_F_c_T); } if (implied_condition_false(expr->cond_false)) { - free_slist(&a_F_c_T); - free_slist(&a_F_c_F); - a_F_c_F = clone_slist(a_F); - overwrite_slist(a_F_c_fake, &a_F_c_F); + free_stree(&a_F_c_T); + free_stree(&a_F_c_F); + a_F_c_F = clone_stree(a_F); + overwrite_stree(a_F_c_fake, &a_F_c_F); } - merge_slist(&a_T_b_T, a_F_c_T); - merge_slist(&a_T_b_F, a_F_c_F); + merge_stree(&a_T_b_T, a_F_c_T); + merge_stree(&a_T_b_F, a_F_c_F); __pop_cond_true_stack(); __pop_cond_false_stack(); __push_cond_stacks(); - FOR_EACH_PTR(a_T_b_T, sm) { + FOR_EACH_SM(a_T_b_T, sm) { __set_true_false_sm(sm, NULL); - } END_FOR_EACH_PTR(sm); - FOR_EACH_PTR(a_T_b_F, sm) { + } END_FOR_EACH_SM(sm); + FOR_EACH_SM(a_T_b_F, sm) { __set_true_false_sm(NULL, sm); - } END_FOR_EACH_PTR(sm); + } END_FOR_EACH_SM(sm); - free_slist(&a_T_b_fake); - free_slist(&a_F_c_fake); + free_stree(&a_T_b_fake); + free_stree(&a_F_c_fake); } static int make_op_unsigned(int op) diff --git a/smatch_db.c b/smatch_db.c index 2a41e98a..59e3702a 100644 --- a/smatch_db.c +++ b/smatch_db.c @@ -443,7 +443,7 @@ static void match_call_marker(struct expression *expr) sql_insert_caller_info(expr, INTERNAL, -1, "%call_marker%", ""); } -static void print_struct_members(struct expression *call, struct expression *expr, int param, struct state_list *slist, +static void print_struct_members(struct expression *call, struct expression *expr, int param, struct AVL *stree, void (*callback)(struct expression *call, int param, char *printed_name, struct smatch_state *state)) { struct sm_state *sm; @@ -464,7 +464,7 @@ static void print_struct_members(struct expression *call, struct expression *exp goto free; len = strlen(name); - FOR_EACH_PTR(slist, sm) { + FOR_EACH_SM(stree, sm) { if (sm->sym != sym) continue; if (strcmp(name, sm->name) == 0) { @@ -483,7 +483,7 @@ static void print_struct_members(struct expression *call, struct expression *exp continue; } callback(call, param, printed_name, sm->state); - } END_FOR_EACH_PTR(sm); + } END_FOR_EACH_SM(sm); free: free_string(name); } @@ -504,7 +504,7 @@ static void match_call_info(struct expression *call) slist = get_all_states(cb->owner); i = 0; FOR_EACH_PTR(call->args, arg) { - print_struct_members(call, arg, i, slist, cb->callback); + print_struct_members(call, arg, i, slist_to_stree(slist), cb->callback); i++; } END_FOR_EACH_PTR(arg); free_slist(&slist); @@ -566,7 +566,7 @@ static int db_callback(void *unused, int argc, char **argv, char **azColName) if (prev_func_id == -1) prev_func_id = func_id; if (func_id != prev_func_id) { - slist = __pop_fake_cur_slist(); + slist = stree_to_slist(__pop_fake_cur_slist()); merge_slist(&final_states, slist); free_slist(&slist); __push_fake_cur_slist(); @@ -677,7 +677,7 @@ static void match_data_from_db(struct symbol *sym) if (!__inline_fn) get_function_pointer_callers(sym); - slist = __pop_fake_cur_slist(); + slist = stree_to_slist(__pop_fake_cur_slist()); merge_slist(&final_states, slist); free_slist(&slist); diff --git a/smatch_extra.c b/smatch_extra.c index a66c3470..151d5f96 100644 --- a/smatch_extra.c +++ b/smatch_extra.c @@ -345,7 +345,7 @@ struct sm_state *__extra_handle_canonical_loops(struct statement *loop, struct s ret = handle_canonical_while_count_down(loop); else ret = handle_canonical_for_loops(loop); - *slist = __pop_fake_cur_slist(); + *slist = stree_to_slist(__pop_fake_cur_slist()); return ret; } diff --git a/smatch_flow.c b/smatch_flow.c index b4c8c6fa..8349671f 100644 --- a/smatch_flow.c +++ b/smatch_flow.c @@ -403,7 +403,7 @@ static void handle_pre_loop(struct statement *stmt) __push_fake_cur_slist(); __split_stmt(stmt->iterator_post_statement); - slist = __pop_fake_cur_slist(); + slist = stree_to_slist(__pop_fake_cur_slist()); __discard_continues(); __discard_false_states(); diff --git a/smatch_function_hooks.c b/smatch_function_hooks.c index 52101d16..3adf6871 100644 --- a/smatch_function_hooks.c +++ b/smatch_function_hooks.c @@ -239,8 +239,8 @@ static int assign_ranged_funcs(const char *fn, struct expression *expr, char *var_name; struct symbol *sym; struct smatch_state *estate; - struct state_list *tmp_slist; - struct state_list *final_states = NULL; + struct AVL *tmp_stree; + struct AVL *final_states = NULL; struct range_list *handled_ranges = NULL; struct call_back_list *same_range_call_backs = NULL; int handled = 0; @@ -268,17 +268,17 @@ static int assign_ranged_funcs(const char *fn, struct expression *expr, estate = alloc_estate_range(tmp->range->min, tmp->range->max); set_extra_mod(var_name, sym, estate); - tmp_slist = __pop_fake_cur_slist(); - merge_slist(&final_states, tmp_slist); - free_slist(&tmp_slist); + tmp_stree = __pop_fake_cur_slist(); + merge_stree(&final_states, tmp_stree); + free_stree(&tmp_stree); handled = 1; } END_FOR_EACH_PTR(tmp); - FOR_EACH_PTR(final_states, sm) { + FOR_EACH_SM(final_states, sm) { __set_sm(sm); - } END_FOR_EACH_PTR(sm); + } END_FOR_EACH_SM(sm); - free_slist(&final_states); + free_stree(&final_states); free: free_string(var_name); return handled; @@ -290,9 +290,9 @@ static int call_implies_callbacks(int comparison, struct expression *expr, sval_ struct fcall_back *tmp; const char *fn; struct data_range *value_range; - struct state_list *true_states = NULL; - struct state_list *false_states = NULL; - struct state_list *tmp_slist; + struct AVL *true_states = NULL; + struct AVL *false_states = NULL; + struct AVL *tmp_stree; struct sm_state *sm; if (expr->fn->type != EXPR_SYMBOL || !expr->fn->symbol) @@ -312,9 +312,9 @@ static int call_implies_callbacks(int comparison, struct expression *expr, sval_ continue; (tmp->u.ranged)(fn, expr, NULL, tmp->info); } END_FOR_EACH_PTR(tmp); - tmp_slist = __pop_fake_cur_slist(); - merge_slist(&true_states, tmp_slist); - free_slist(&tmp_slist); + tmp_stree = __pop_fake_cur_slist(); + merge_stree(&true_states, tmp_stree); + free_stree(&tmp_stree); /* set false states */ __push_fake_cur_slist(); @@ -325,19 +325,19 @@ static int call_implies_callbacks(int comparison, struct expression *expr, sval_ continue; (tmp->u.ranged)(fn, expr, NULL, tmp->info); } END_FOR_EACH_PTR(tmp); - tmp_slist = __pop_fake_cur_slist(); - merge_slist(&false_states, tmp_slist); - free_slist(&tmp_slist); + tmp_stree = __pop_fake_cur_slist(); + merge_stree(&false_states, tmp_stree); + free_stree(&tmp_stree); - FOR_EACH_PTR(true_states, sm) { + FOR_EACH_SM(true_states, sm) { __set_true_false_sm(sm, NULL); - } END_FOR_EACH_PTR(sm); - FOR_EACH_PTR(false_states, sm) { + } END_FOR_EACH_SM(sm); + FOR_EACH_SM(false_states, sm) { __set_true_false_sm(NULL, sm); - } END_FOR_EACH_PTR(sm); + } END_FOR_EACH_SM(sm); - free_slist(&true_states); - free_slist(&false_states); + free_stree(&true_states); + free_stree(&false_states); return 1; } @@ -347,7 +347,7 @@ struct db_callback_info { struct expression *expr; struct range_list *rl; int left; - struct state_list *slist; + struct AVL *stree; struct db_implies_list *callbacks; }; static struct db_callback_info db_info; @@ -389,8 +389,8 @@ static int db_compare_callback(void *unused, int argc, char **argv, char **azCol void compare_db_return_states_callbacks(int comparison, struct expression *expr, sval_t sval, int left) { - struct state_list *true_states; - struct state_list *false_states; + struct AVL *true_states; + struct AVL *false_states; struct sm_state *sm; if (expr->fn->type != EXPR_SYMBOL || !expr->fn->symbol) @@ -416,17 +416,17 @@ void compare_db_return_states_callbacks(int comparison, struct expression *expr, db_compare_callback); false_states = __pop_fake_cur_slist(); - FOR_EACH_PTR(true_states, sm) { + FOR_EACH_SM(true_states, sm) { __set_true_false_sm(sm, NULL); - } END_FOR_EACH_PTR(sm); - FOR_EACH_PTR(false_states, sm) { + } END_FOR_EACH_SM(sm); + FOR_EACH_SM(false_states, sm) { __set_true_false_sm(NULL, sm); - } END_FOR_EACH_PTR(sm); + } END_FOR_EACH_SM(sm); call_return_states_after_hooks(); - free_slist(&true_states); - free_slist(&false_states); + free_stree(&true_states); + free_stree(&false_states); } @@ -445,7 +445,7 @@ static int db_assign_return_states_callback(void *unused, int argc, char **argv, int type, param; char *key, *value; struct return_implies_callback *tmp; - struct state_list *slist; + struct AVL *stree; int return_id; if (argc != 6) @@ -463,9 +463,9 @@ static int db_assign_return_states_callback(void *unused, int argc, char **argv, value = argv[5]; if (prev_return_id != -1 && return_id != prev_return_id) { - slist = __pop_fake_cur_slist(); - merge_slist(&db_info.slist, slist); - free_slist(&slist); + stree = __pop_fake_cur_slist(); + merge_stree(&db_info.stree, stree); + free_stree(&stree); __push_fake_cur_slist(); } prev_return_id = return_id; @@ -484,7 +484,7 @@ static int db_return_states_assign(struct expression *expr) { struct expression *right; struct sm_state *sm; - struct state_list *slist; + struct AVL *stree; int handled = 0; right = strip_expr(expr->right); @@ -493,21 +493,21 @@ static int db_return_states_assign(struct expression *expr) prev_return_id = -1; db_info.expr = expr; - db_info.slist = NULL; + db_info.stree = NULL; call_return_states_before_hooks(); __push_fake_cur_slist(); sql_select_return_states("return_id, return, type, parameter, key, value", right, db_assign_return_states_callback); - slist = __pop_fake_cur_slist(); - merge_slist(&db_info.slist, slist); - free_slist(&slist); + stree = __pop_fake_cur_slist(); + merge_stree(&db_info.stree, stree); + free_stree(&stree); - FOR_EACH_PTR(db_info.slist, sm) { + FOR_EACH_SM(db_info.stree, sm) { __set_sm(sm); handled = 1; - } END_FOR_EACH_PTR(sm); + } END_FOR_EACH_SM(sm); call_return_states_after_hooks(); @@ -577,7 +577,7 @@ static int db_return_states_callback(void *unused, int argc, char **argv, char * int type, param; char *key, *value; struct return_implies_callback *tmp; - struct state_list *slist; + struct AVL *stree; int return_id; if (argc != 6) @@ -592,9 +592,9 @@ static int db_return_states_callback(void *unused, int argc, char **argv, char * value = argv[5]; if (prev_return_id != -1 && return_id != prev_return_id) { - slist = __pop_fake_cur_slist(); - merge_slist(&db_info.slist, slist); - free_slist(&slist); + stree = __pop_fake_cur_slist(); + merge_stree(&db_info.stree, stree); + free_stree(&stree); __push_fake_cur_slist(); __unnullify_path(); } @@ -611,7 +611,7 @@ static int db_return_states_callback(void *unused, int argc, char **argv, char * static void db_return_states(struct expression *expr) { struct sm_state *sm; - struct state_list *slist; + struct AVL *stree; if (expr->fn->type != EXPR_SYMBOL || !expr->fn->symbol) return; @@ -620,7 +620,7 @@ static void db_return_states(struct expression *expr) prev_return_id = -1; db_info.expr = expr; - db_info.slist = NULL; + db_info.stree = NULL; call_return_states_before_hooks(); @@ -628,13 +628,13 @@ static void db_return_states(struct expression *expr) __unnullify_path(); sql_select_return_states("return_id, return, type, parameter, key, value", expr, db_return_states_callback); - slist = __pop_fake_cur_slist(); - merge_slist(&db_info.slist, slist); - free_slist(&slist); + stree = __pop_fake_cur_slist(); + merge_stree(&db_info.stree, stree); + free_stree(&stree); - FOR_EACH_PTR(db_info.slist, sm) { + FOR_EACH_SM(db_info.stree, sm) { __set_sm(sm); - } END_FOR_EACH_PTR(sm); + } END_FOR_EACH_SM(sm); call_return_states_after_hooks(); } diff --git a/smatch_implied.c b/smatch_implied.c index 7f8e8be2..b5d4d3d5 100644 --- a/smatch_implied.c +++ b/smatch_implied.c @@ -612,7 +612,7 @@ struct state_list *__implied_case_slist(struct expression *switch_expr, __push_fake_cur_slist(); __unnullify_path(); set_extra_nomod(name, sym, alloc_estate_rl(vals)); - extra_states = __pop_fake_cur_slist(); + extra_states = stree_to_slist(__pop_fake_cur_slist()); overwrite_slist(extra_states, &true_states); overwrite_slist(true_states, &ret); free_slist(&extra_states); diff --git a/smatch_states.c b/smatch_states.c index e13ad44b..059f0462 100644 --- a/smatch_states.c +++ b/smatch_states.c @@ -166,10 +166,10 @@ void __push_fake_cur_slist() __save_pre_cond_states(); } -struct state_list *__pop_fake_cur_slist() +struct AVL *__pop_fake_cur_slist() { __use_pre_cond_states(); - return stree_to_slist(pop_stree(&fake_cur_stree_stack)); + return pop_stree(&fake_cur_stree_stack); } void __free_fake_cur_slist() @@ -599,32 +599,32 @@ void __push_cond_stacks(void) push_stree(&cond_false_stack, NULL); } -struct state_list *__copy_cond_true_states(void) +struct AVL *__copy_cond_true_states(void) { struct AVL *ret; ret = pop_stree(&cond_true_stack); push_stree(&cond_true_stack, clone_stree(ret)); - return stree_to_slist(ret); + return ret; } -struct state_list *__copy_cond_false_states(void) +struct AVL *__copy_cond_false_states(void) { struct AVL *ret; ret = pop_stree(&cond_false_stack); push_stree(&cond_false_stack, clone_stree(ret)); - return stree_to_slist(ret); + return ret; } -struct state_list *__pop_cond_true_stack(void) +struct AVL *__pop_cond_true_stack(void) { - return stree_to_slist(pop_stree(&cond_true_stack)); + return pop_stree(&cond_true_stack); } -struct state_list *__pop_cond_false_stack(void) +struct AVL *__pop_cond_false_stack(void) { - return stree_to_slist(pop_stree(&cond_false_stack)); + return pop_stree(&cond_false_stack); } /* -- 2.11.4.GIT