Print this page
11506 smatch resync


  79         int i = 0;
  80 
  81         FOR_EACH_PTR(expr->args, arg) {
  82                 if (get_state_expr(my_id, arg) == &nospec)
  83                         sql_insert_caller_info(expr, NOSPEC, i, "$", "");
  84                 i++;
  85         } END_FOR_EACH_PTR(arg);
  86 }
  87 
  88 static void struct_member_callback(struct expression *call, int param, char *printed_name, struct sm_state *sm)
  89 {
  90         struct range_list *rl;
  91 
  92         if (!get_user_rl_var_sym(sm->name, sm->sym, &rl))
  93                 return;
  94         sql_insert_caller_info(call, NOSPEC, param, printed_name, "");
  95 }
  96 
  97 static void returned_struct_members(int return_id, char *return_ranges, struct expression *expr)
  98 {

  99         struct symbol *returned_sym;
 100         struct sm_state *sm;
 101         const char *param_name;
 102         struct range_list *rl;
 103         int param;
 104 
 105         returned_sym = expr_to_sym(expr);
 106 
 107         FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {


 108                 param = get_param_num_from_sym(sm->sym);
 109                 if (param < 0) {
 110                         if (!returned_sym || returned_sym != sm->sym)
 111                                 continue;
 112                         param = -1;
 113                 }
 114 
 115                 param_name = get_param_name(sm);
 116                 if (!param_name)
 117                         continue;
 118                 if (param != -1 && strcmp(param_name, "$") == 0)
 119                         continue;
 120 
 121                 if (!get_user_rl_var_sym(sm->name, sm->sym, &rl))
 122                         continue;
 123 
 124                 sql_insert_return_states(return_id, return_ranges, NOSPEC, param, param_name, "");
 125         } END_FOR_EACH_SM(sm);
 126 
 127         if (is_nospec(expr) && get_user_rl(expr, &rl))


 205                         continue;
 206                 type = estate_type(sm->state);
 207                 if (!type || type->type != SYM_BASETYPE)
 208                         continue;
 209                 if (!is_capped_var_sym(sm->name, sm->sym))
 210                         continue;
 211                 set_state(my_id, sm->name, sm->sym, &nospec);
 212         } END_FOR_EACH_SM(sm);
 213         free_stree(&stree);
 214 }
 215 
 216 static void match_barrier(struct statement *stmt)
 217 {
 218         char *macro;
 219 
 220         macro = get_macro_name(stmt->pos);
 221         if (!macro)
 222                 return;
 223         if (strcmp(macro, "rmb") != 0 &&
 224             strcmp(macro, "smp_rmb") != 0 &&
 225             strcmp(macro, "barrier_nospec") != 0)

 226                 return;
 227 
 228         set_state(barrier_id, "barrier", NULL, &nospec);
 229         mark_user_data_as_nospec();
 230 }
 231 
 232 static void db_returns_barrier(struct expression *expr, int param, char *key, char *value)
 233 {
 234         mark_user_data_as_nospec();
 235 }
 236 









 237 void check_nospec(int id)
 238 {
 239         my_id = id;
 240 
 241         add_hook(&nospec_assign, ASSIGNMENT_HOOK);
 242 
 243         select_caller_info_hook(set_param_nospec, NOSPEC);
 244         add_unmatched_state_hook(my_id, &unmatched_state);
 245 
 246         add_hook(&match_call_info, FUNCTION_CALL_HOOK);
 247         add_member_info_callback(my_id, struct_member_callback);
 248         add_split_return_callback(&returned_struct_members);
 249         select_return_states_hook(NOSPEC, &db_returns_nospec);
 250         select_return_states_hook(NOSPEC_WB, &db_returns_barrier);

 251 
 252         add_hook(&match_asm, ASM_HOOK);
 253         add_hook(&match_after_nospec_asm, STMT_HOOK_AFTER);
 254 }
 255 
 256 void check_nospec_barrier(int id)
 257 {
 258         barrier_id = id;
 259 
 260         add_hook(&match_barrier, ASM_HOOK);
 261 }


  79         int i = 0;
  80 
  81         FOR_EACH_PTR(expr->args, arg) {
  82                 if (get_state_expr(my_id, arg) == &nospec)
  83                         sql_insert_caller_info(expr, NOSPEC, i, "$", "");
  84                 i++;
  85         } END_FOR_EACH_PTR(arg);
  86 }
  87 
  88 static void struct_member_callback(struct expression *call, int param, char *printed_name, struct sm_state *sm)
  89 {
  90         struct range_list *rl;
  91 
  92         if (!get_user_rl_var_sym(sm->name, sm->sym, &rl))
  93                 return;
  94         sql_insert_caller_info(call, NOSPEC, param, printed_name, "");
  95 }
  96 
  97 static void returned_struct_members(int return_id, char *return_ranges, struct expression *expr)
  98 {
  99         struct stree *start_states = get_start_states();
 100         struct symbol *returned_sym;
 101         struct sm_state *sm;
 102         const char *param_name;
 103         struct range_list *rl;
 104         int param;
 105 
 106         returned_sym = expr_to_sym(expr);
 107 
 108         FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
 109                 if (get_state_stree(start_states, my_id, sm->name, sm->sym) == sm->state)
 110                         continue;
 111                 param = get_param_num_from_sym(sm->sym);
 112                 if (param < 0) {
 113                         if (!returned_sym || returned_sym != sm->sym)
 114                                 continue;
 115                         param = -1;
 116                 }
 117 
 118                 param_name = get_param_name(sm);
 119                 if (!param_name)
 120                         continue;
 121                 if (param != -1 && strcmp(param_name, "$") == 0)
 122                         continue;
 123 
 124                 if (!get_user_rl_var_sym(sm->name, sm->sym, &rl))
 125                         continue;
 126 
 127                 sql_insert_return_states(return_id, return_ranges, NOSPEC, param, param_name, "");
 128         } END_FOR_EACH_SM(sm);
 129 
 130         if (is_nospec(expr) && get_user_rl(expr, &rl))


 208                         continue;
 209                 type = estate_type(sm->state);
 210                 if (!type || type->type != SYM_BASETYPE)
 211                         continue;
 212                 if (!is_capped_var_sym(sm->name, sm->sym))
 213                         continue;
 214                 set_state(my_id, sm->name, sm->sym, &nospec);
 215         } END_FOR_EACH_SM(sm);
 216         free_stree(&stree);
 217 }
 218 
 219 static void match_barrier(struct statement *stmt)
 220 {
 221         char *macro;
 222 
 223         macro = get_macro_name(stmt->pos);
 224         if (!macro)
 225                 return;
 226         if (strcmp(macro, "rmb") != 0 &&
 227             strcmp(macro, "smp_rmb") != 0 &&
 228             strcmp(macro, "barrier_nospec") != 0 &&
 229             strcmp(macro, "preempt_disable") != 0)
 230                 return;
 231 
 232         set_state(barrier_id, "barrier", NULL, &nospec);
 233         mark_user_data_as_nospec();
 234 }
 235 
 236 static void db_returns_barrier(struct expression *expr, int param, char *key, char *value)
 237 {
 238         mark_user_data_as_nospec();
 239 }
 240 
 241 static void select_return_stmt_cnt(struct expression *expr, int param, char *key, char *value)
 242 {
 243         int cnt;
 244 
 245         cnt = atoi(value);
 246         if (cnt > 400)
 247                 mark_user_data_as_nospec();
 248 }
 249 
 250 void check_nospec(int id)
 251 {
 252         my_id = id;
 253 
 254         add_hook(&nospec_assign, ASSIGNMENT_HOOK);
 255 
 256         select_caller_info_hook(set_param_nospec, NOSPEC);
 257         add_unmatched_state_hook(my_id, &unmatched_state);
 258 
 259         add_hook(&match_call_info, FUNCTION_CALL_HOOK);
 260         add_member_info_callback(my_id, struct_member_callback);
 261         add_split_return_callback(&returned_struct_members);
 262         select_return_states_hook(NOSPEC, &db_returns_nospec);
 263         select_return_states_hook(NOSPEC_WB, &db_returns_barrier);
 264         select_return_states_hook(STMT_CNT, &select_return_stmt_cnt);
 265 
 266         add_hook(&match_asm, ASM_HOOK);
 267         add_hook(&match_after_nospec_asm, STMT_HOOK_AFTER);
 268 }
 269 
 270 void check_nospec_barrier(int id)
 271 {
 272         barrier_id = id;
 273 
 274         add_hook(&match_barrier, ASM_HOOK);
 275 }