Print this page
11506 smatch resync


 131         } END_FOR_EACH_PTR(tmp);
 132 
 133         return 0;
 134 }
 135 
 136 static void print_one_mod_param(int return_id, char *return_ranges,
 137                         int param, struct sm_state *sm, struct string_list **totally_filtered)
 138 {
 139         const char *param_name;
 140 
 141         param_name = get_param_name(sm);
 142         if (!param_name)
 143                 return;
 144         if (is_whole_rl(estate_rl(sm->state)))
 145                 return;
 146         if (!estate_rl(sm->state)) {
 147                 insert_string(totally_filtered, (char *)sm->name);
 148                 return;
 149         }
 150 





 151         sql_insert_return_states(return_id, return_ranges, PARAM_FILTER, param,
 152                         param_name, show_rl(estate_rl(sm->state)));
 153 }
 154 
 155 static void print_return_value_param(int return_id, char *return_ranges, struct expression *expr)
 156 {
 157         struct sm_state *tmp;
 158         struct sm_state *sm;
 159         struct string_list *totally_filtered = NULL;
 160         int param;
 161 
 162         FOR_EACH_MY_SM(SMATCH_EXTRA, __get_cur_stree(), tmp) {
 163                 param = get_param_num_from_sym(tmp->sym);
 164                 if (param < 0)
 165                         continue;
 166 
 167                 /* on stack parameters are handled in smatch_param_limit.c */
 168                 if (tmp->sym->ident && strcmp(tmp->sym->ident->name, tmp->name) == 0)
 169                         continue;
 170 


 181 
 182 int param_has_filter_data(struct sm_state *sm)
 183 {
 184         struct smatch_state *state;
 185 
 186         state = get_state(my_id, sm->name, sm->sym);
 187         if (!state) {
 188                 if (get_assigned_expr_name_sym(sm->name, sm->sym))
 189                         return 0;
 190                 return 1;
 191         }
 192         if (estate_rl(state))
 193                 return 1;
 194         return 0;
 195 }
 196 
 197 void register_param_filter(int id)
 198 {
 199         my_id = id;
 200 

 201         add_hook(&save_start_states, AFTER_DEF_HOOK);
 202         add_hook(&free_start_states, AFTER_FUNC_HOOK);
 203 
 204         add_extra_mod_hook(&extra_mod_hook);
 205         add_unmatched_state_hook(my_id, &unmatched_state);
 206         add_pre_merge_hook(my_id, &pre_merge_hook);
 207         add_merge_hook(my_id, &merge_estates);
 208 
 209         add_hook(&match_save_states, INLINE_FN_START);
 210         add_hook(&match_restore_states, INLINE_FN_END);
 211 
 212         add_split_return_callback(&print_return_value_param);
 213 }
 214 


 131         } END_FOR_EACH_PTR(tmp);
 132 
 133         return 0;
 134 }
 135 
 136 static void print_one_mod_param(int return_id, char *return_ranges,
 137                         int param, struct sm_state *sm, struct string_list **totally_filtered)
 138 {
 139         const char *param_name;
 140 
 141         param_name = get_param_name(sm);
 142         if (!param_name)
 143                 return;
 144         if (is_whole_rl(estate_rl(sm->state)))
 145                 return;
 146         if (!estate_rl(sm->state)) {
 147                 insert_string(totally_filtered, (char *)sm->name);
 148                 return;
 149         }
 150 
 151         if (is_ignored_kernel_data(param_name)) {
 152                 insert_string(totally_filtered, (char *)sm->name);
 153                 return;
 154         }
 155 
 156         sql_insert_return_states(return_id, return_ranges, PARAM_FILTER, param,
 157                         param_name, show_rl(estate_rl(sm->state)));
 158 }
 159 
 160 static void print_return_value_param(int return_id, char *return_ranges, struct expression *expr)
 161 {
 162         struct sm_state *tmp;
 163         struct sm_state *sm;
 164         struct string_list *totally_filtered = NULL;
 165         int param;
 166 
 167         FOR_EACH_MY_SM(SMATCH_EXTRA, __get_cur_stree(), tmp) {
 168                 param = get_param_num_from_sym(tmp->sym);
 169                 if (param < 0)
 170                         continue;
 171 
 172                 /* on stack parameters are handled in smatch_param_limit.c */
 173                 if (tmp->sym->ident && strcmp(tmp->sym->ident->name, tmp->name) == 0)
 174                         continue;
 175 


 186 
 187 int param_has_filter_data(struct sm_state *sm)
 188 {
 189         struct smatch_state *state;
 190 
 191         state = get_state(my_id, sm->name, sm->sym);
 192         if (!state) {
 193                 if (get_assigned_expr_name_sym(sm->name, sm->sym))
 194                         return 0;
 195                 return 1;
 196         }
 197         if (estate_rl(state))
 198                 return 1;
 199         return 0;
 200 }
 201 
 202 void register_param_filter(int id)
 203 {
 204         my_id = id;
 205 
 206         set_dynamic_states(my_id);
 207         add_hook(&save_start_states, AFTER_DEF_HOOK);
 208         add_hook(&free_start_states, AFTER_FUNC_HOOK);
 209 
 210         add_extra_mod_hook(&extra_mod_hook);
 211         add_unmatched_state_hook(my_id, &unmatched_state);
 212         add_pre_merge_hook(my_id, &pre_merge_hook);
 213         add_merge_hook(my_id, &merge_estates);
 214 
 215         add_hook(&match_save_states, INLINE_FN_START);
 216         add_hook(&match_restore_states, INLINE_FN_END);
 217 
 218         add_split_return_callback(&print_return_value_param);
 219 }
 220