Print this page
11506 smatch resync


 147                         continue;
 148                 if (ret > 0)
 149                         return 0;
 150                 if (name[len] == '-')
 151                         return 1;
 152         } END_FOR_EACH_PTR(tmp);
 153 
 154         return 0;
 155 }
 156 
 157 static void print_return_value_param(int return_id, char *return_ranges, struct expression *expr)
 158 {
 159         struct sm_state *sm;
 160         struct smatch_state *extra;
 161         int param;
 162         struct range_list *rl;
 163         const char *param_name;
 164         struct string_list *set_list = NULL;
 165         char *math_str;
 166         char buf[256];
 167         sval_t sval;
 168 
 169         FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
 170                 if (!estate_rl(sm->state))
 171                         continue;
 172                 extra = get_state(SMATCH_EXTRA, sm->name, sm->sym);
 173                 if (extra) {
 174                         rl = rl_intersection(estate_rl(sm->state), estate_rl(extra));
 175                         if (!rl)
 176                                 continue;
 177                 } else {
 178                         rl = estate_rl(sm->state);
 179                 }
 180 
 181                 param = get_param_num_from_sym(sm->sym);
 182                 if (param < 0)
 183                         continue;
 184                 param_name = get_param_name(sm);
 185                 if (!param_name)
 186                         continue;
 187                 if (strcmp(param_name, "$") == 0) {
 188                         insert_string(&set_list, (char *)sm->name);
 189                         continue;
 190                 }




 191 
 192                 if (rl_to_sval(rl, &sval)) {
 193                         insert_string(&set_list, (char *)sm->name);
 194                         sql_insert_return_states(return_id, return_ranges,
 195                                         param_has_filter_data(sm) ? PARAM_ADD : PARAM_SET,
 196                                         param, param_name, show_rl(rl));
 197                         continue;
 198                 }
 199 
 200                 math_str = get_value_in_terms_of_parameter_math_var_sym(sm->name, sm->sym);
 201                 if (math_str) {
 202                         snprintf(buf, sizeof(buf), "%s[%s]", show_rl(rl), math_str);
 203                         insert_string(&set_list, (char *)sm->name);
 204                         sql_insert_return_states(return_id, return_ranges,
 205                                         param_has_filter_data(sm) ? PARAM_ADD : PARAM_SET,
 206                                         param, param_name, buf);
 207                         continue;
 208                 }
 209 
 210                 /* no useful information here. */
 211                 if (is_whole_rl(rl) && parent_set(set_list, sm->name))
 212                         continue;
 213                 insert_string(&set_list, (char *)sm->name);
 214 
 215                 sql_insert_return_states(return_id, return_ranges,
 216                                          param_has_filter_data(sm) ? PARAM_ADD : PARAM_SET,


 243 int param_was_set(struct expression *expr)
 244 {
 245         char *name;
 246         struct symbol *sym;
 247         int ret = 0;
 248 
 249         name = expr_to_var_sym(expr, &sym);
 250         if (!name || !sym)
 251                 goto free;
 252 
 253         ret = param_was_set_var_sym(name, sym);
 254 free:
 255         free_string(name);
 256         return ret;
 257 }
 258 
 259 void register_param_set(int id)
 260 {
 261         my_id = id;
 262 

 263         add_extra_mod_hook(&extra_mod_hook);
 264         add_hook(match_array_assignment, ASSIGNMENT_HOOK);
 265         add_unmatched_state_hook(my_id, &unmatched_state);
 266         add_merge_hook(my_id, &merge_estates);
 267         add_split_return_callback(&print_return_value_param);
 268 }
 269 


 147                         continue;
 148                 if (ret > 0)
 149                         return 0;
 150                 if (name[len] == '-')
 151                         return 1;
 152         } END_FOR_EACH_PTR(tmp);
 153 
 154         return 0;
 155 }
 156 
 157 static void print_return_value_param(int return_id, char *return_ranges, struct expression *expr)
 158 {
 159         struct sm_state *sm;
 160         struct smatch_state *extra;
 161         int param;
 162         struct range_list *rl;
 163         const char *param_name;
 164         struct string_list *set_list = NULL;
 165         char *math_str;
 166         char buf[256];

 167 
 168         FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
 169                 if (!estate_rl(sm->state))
 170                         continue;
 171                 extra = get_state(SMATCH_EXTRA, sm->name, sm->sym);
 172                 if (extra) {
 173                         rl = rl_intersection(estate_rl(sm->state), estate_rl(extra));
 174                         if (!rl)
 175                                 continue;
 176                 } else {
 177                         rl = estate_rl(sm->state);
 178                 }
 179 
 180                 param = get_param_num_from_sym(sm->sym);
 181                 if (param < 0)
 182                         continue;
 183                 param_name = get_param_name(sm);
 184                 if (!param_name)
 185                         continue;
 186                 if (strcmp(param_name, "$") == 0) {
 187                         insert_string(&set_list, (char *)sm->name);
 188                         continue;
 189                 }
 190                 if (is_recursive_member(param_name)) {
 191                         insert_string(&set_list, (char *)sm->name);
 192                         continue;
 193                 }
 194 
 195                 if (is_ignored_kernel_data(param_name)) {
 196                         insert_string(&set_list, (char *)sm->name);



 197                         continue;
 198                 }
 199 
 200                 math_str = get_value_in_terms_of_parameter_math_var_sym(sm->name, sm->sym);
 201                 if (math_str) {
 202                         snprintf(buf, sizeof(buf), "%s[%s]", show_rl(rl), math_str);
 203                         insert_string(&set_list, (char *)sm->name);
 204                         sql_insert_return_states(return_id, return_ranges,
 205                                         param_has_filter_data(sm) ? PARAM_ADD : PARAM_SET,
 206                                         param, param_name, buf);
 207                         continue;
 208                 }
 209 
 210                 /* no useful information here. */
 211                 if (is_whole_rl(rl) && parent_set(set_list, sm->name))
 212                         continue;
 213                 insert_string(&set_list, (char *)sm->name);
 214 
 215                 sql_insert_return_states(return_id, return_ranges,
 216                                          param_has_filter_data(sm) ? PARAM_ADD : PARAM_SET,


 243 int param_was_set(struct expression *expr)
 244 {
 245         char *name;
 246         struct symbol *sym;
 247         int ret = 0;
 248 
 249         name = expr_to_var_sym(expr, &sym);
 250         if (!name || !sym)
 251                 goto free;
 252 
 253         ret = param_was_set_var_sym(name, sym);
 254 free:
 255         free_string(name);
 256         return ret;
 257 }
 258 
 259 void register_param_set(int id)
 260 {
 261         my_id = id;
 262 
 263         set_dynamic_states(my_id);
 264         add_extra_mod_hook(&extra_mod_hook);
 265         add_hook(match_array_assignment, ASSIGNMENT_HOOK);
 266         add_unmatched_state_hook(my_id, &unmatched_state);
 267         add_merge_hook(my_id, &merge_estates);
 268         add_split_return_callback(&print_return_value_param);
 269 }
 270