smatch_hooks.c

   1 /*
   2  * Copyright (C) 2006 Dan Carpenter.
   3  *
   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.
   8  *
   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.
  13  *
  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
  16  */
  17
  18 #include "smatch.h"
  19
  20 enum data_type {
  21         NO_DATA,
  22         EXPR_PTR,
  23         STMT_PTR,
  24         SYMBOL_PTR,
  25         SYM_LIST_PTR,
  26 };
  27
  28 struct hook_container {
  29         int hook_type;
  30         int owner;
  31         void *fn;
  32 };
  33 ALLOCATOR(hook_container, "hook functions");
  34 DECLARE_PTR_LIST(hook_func_list, struct hook_container);
  35
  36 typedef void (sym_list_func)(struct symbol_list *sym_list);
  37 typedef void (array_init_hook)(struct expression *array, int nr);
  38
  39 static struct hook_func_list *merge_funcs;
  40 static struct hook_func_list *unmatched_state_funcs;
  41 static struct hook_func_list *array_init_hooks;
  42 static struct hook_func_list *hook_array[NUM_HOOKS] = {};
  43 static const enum data_type data_types[NUM_HOOKS] = {
  44         [EXPR_HOOK] = EXPR_PTR,
  45         [EXPR_HOOK_AFTER] = EXPR_PTR,
  46         [STMT_HOOK] = STMT_PTR,
  47         [STMT_HOOK_AFTER] = STMT_PTR,
  48         [SYM_HOOK] = EXPR_PTR,
  49         [STRING_HOOK] = EXPR_PTR,
  50         [DECLARATION_HOOK] = SYMBOL_PTR,
  51         [DECLARATION_HOOK_AFTER] = SYMBOL_PTR,
  52         [ASSIGNMENT_HOOK] = EXPR_PTR,
  53         [ASSIGNMENT_HOOK_AFTER] = EXPR_PTR,
  54         [RAW_ASSIGNMENT_HOOK] = EXPR_PTR,
  55         [GLOBAL_ASSIGNMENT_HOOK] = EXPR_PTR,
  56         [CALL_ASSIGNMENT_HOOK] = EXPR_PTR,
  57         [MACRO_ASSIGNMENT_HOOK] = EXPR_PTR,
  58         [BINOP_HOOK] = EXPR_PTR,
  59         [OP_HOOK] = EXPR_PTR,
  60         [LOGIC_HOOK] = EXPR_PTR,
  61         [PRELOOP_HOOK] = STMT_PTR,
  62         [POSTLOOP_HOOK] = STMT_PTR,
  63         [AFTER_LOOP_NO_BREAKS] = STMT_PTR,
  64         [CONDITION_HOOK] = EXPR_PTR,
  65         [SELECT_HOOK] = EXPR_PTR,
  66         [WHOLE_CONDITION_HOOK] = EXPR_PTR,
  67         [FUNCTION_CALL_HOOK_BEFORE] = EXPR_PTR,
  68         [FUNCTION_CALL_HOOK] = EXPR_PTR,
  69         [CALL_HOOK_AFTER_INLINE] = EXPR_PTR,
  70         [FUNCTION_CALL_HOOK_AFTER_DB] = EXPR_PTR,
  71         [DEREF_HOOK] = EXPR_PTR,
  72         [CASE_HOOK] = NO_DATA,
  73         [ASM_HOOK] = STMT_PTR,
  74         [CAST_HOOK] = EXPR_PTR,
  75         [SIZEOF_HOOK] = EXPR_PTR,
  76         [BASE_HOOK] = SYMBOL_PTR,
  77         [FUNC_DEF_HOOK] = SYMBOL_PTR,
  78         [AFTER_DEF_HOOK] = SYMBOL_PTR,
  79         [END_FUNC_HOOK] = SYMBOL_PTR,
  80         [AFTER_FUNC_HOOK] = SYMBOL_PTR,
  81         [RETURN_HOOK] = EXPR_PTR,
  82         [INLINE_FN_START] = EXPR_PTR,
  83         [INLINE_FN_END] = EXPR_PTR,
  84         [END_FILE_HOOK] = SYM_LIST_PTR,
  85 };
  86
  87 void (**pre_merge_hooks)(struct sm_state *cur, struct sm_state *other);
  88
  89 struct scope_container {
  90         void *fn;
  91         void *data;
  92 };
  93 ALLOCATOR(scope_container, "scope hook functions");
  94 DECLARE_PTR_LIST(scope_hook_list, struct scope_container);
  95 DECLARE_PTR_LIST(scope_hook_stack, struct scope_hook_list);
  96 static struct scope_hook_stack *scope_hooks;
  97 int my_id;
  98
  99 extern int __cur_check_id;
 100 void add_hook(void *func, enum hook_type type)
 101 {
 102         struct hook_container *container = __alloc_hook_container(0);
 103
 104         container->owner = __cur_check_id;
 105         container->hook_type = type;
 106         container->fn = func;
 107
 108         add_ptr_list(&hook_array[type], container);
 109 }
 110
 111 void add_merge_hook(int client_id, merge_func_t *func)
 112 {
 113         struct hook_container *container = __alloc_hook_container(0);
 114         container->owner = client_id;
 115         container->fn = func;
 116         add_ptr_list(&merge_funcs, container);
 117 }
 118
 119 void add_unmatched_state_hook(int client_id, unmatched_func_t *func)
 120 {
 121         struct hook_container *container = __alloc_hook_container(0);
 122         container->owner = client_id;
 123         container->fn = func;
 124         add_ptr_list(&unmatched_state_funcs, container);
 125 }
 126
 127 void add_pre_merge_hook(int client_id, void (*hook)(struct sm_state *cur, struct sm_state *other))
 128 {
 129         pre_merge_hooks[client_id] = hook;
 130 }
 131
 132 static void pass_expr_to_client(void *fn, void *data)
 133 {
 134         ((expr_func *)fn)((struct expression *)data);
 135 }
 136
 137 static void pass_stmt_to_client(void *fn, void *data)
 138 {
 139         ((stmt_func *)fn)((struct statement *)data);
 140 }
 141
 142 static void pass_sym_to_client(void *fn, void *data)
 143 {
 144         ((sym_func *)fn)((struct symbol *)data);
 145 }
 146
 147 static void pass_sym_list_to_client(void *fn, void *data)
 148 {
 149         ((sym_list_func *)fn)((struct symbol_list *)data);
 150 }
 151
 152 void __pass_to_client(void *data, enum hook_type type)
 153 {
 154         struct hook_container *container;
 155
 156         if (__debug_skip)
 157                 return;
 158
 159         FOR_EACH_PTR(hook_array[type], container) {
 160                 switch (data_types[type]) {
 161                 case EXPR_PTR:
 162                         pass_expr_to_client(container->fn, data);
 163                         break;
 164                 case STMT_PTR:
 165                         pass_stmt_to_client(container->fn, data);
 166                         break;
 167                 case SYMBOL_PTR:
 168                         pass_sym_to_client(container->fn, data);
 169                         break;
 170                 case SYM_LIST_PTR:
 171                         pass_sym_list_to_client(container->fn, data);
 172                         break;
 173                 default:
 174                         sm_warning("internal error. Unhandled hook type: %d", type);
 175                 }
 176         } END_FOR_EACH_PTR(container);
 177 }
 178
 179 void __pass_case_to_client(struct expression *switch_expr,
 180                            struct range_list *rl)
 181 {
 182         typedef void (case_func)(struct expression *switch_expr,
 183                                  struct range_list *rl);
 184         struct hook_container *container;
 185
 186         FOR_EACH_PTR(hook_array[CASE_HOOK], container) {
 187                 ((case_func *)container->fn)(switch_expr, rl);
 188         } END_FOR_EACH_PTR(container);
 189 }
 190
 191 int __has_merge_function(int client_id)
 192 {
 193         struct hook_container *tmp;
 194
 195         FOR_EACH_PTR(merge_funcs, tmp) {
 196                 if (tmp->owner == client_id)
 197                         return 1;
 198         } END_FOR_EACH_PTR(tmp);
 199         return 0;
 200 }
 201
 202 struct smatch_state *__client_merge_function(int owner,
 203                                              struct smatch_state *s1,
 204                                              struct smatch_state *s2)
 205 {
 206         struct smatch_state *tmp_state;
 207         struct hook_container *tmp;
 208
 209         /* Pass NULL states first and the rest alphabetically by name */
 210         if (!s2 || (s1 && strcmp(s2->name, s1->name) < 0)) {
 211                 tmp_state = s1;
 212                 s1 = s2;
 213                 s2 = tmp_state;
 214         }
 215
 216         FOR_EACH_PTR(merge_funcs, tmp) {
 217                 if (tmp->owner == owner)
 218                         return ((merge_func_t *)tmp->fn)(s1, s2);
 219         } END_FOR_EACH_PTR(tmp);
 220         return &undefined;
 221 }
 222
 223 struct smatch_state *__client_unmatched_state_function(struct sm_state *sm)
 224 {
 225         struct hook_container *tmp;
 226
 227         FOR_EACH_PTR(unmatched_state_funcs, tmp) {
 228                 if (tmp->owner == sm->owner)
 229                         return ((unmatched_func_t *)tmp->fn)(sm);
 230         } END_FOR_EACH_PTR(tmp);
 231         return &undefined;
 232 }
 233
 234 void call_pre_merge_hook(struct sm_state *cur, struct sm_state *other)
 235 {
 236         if (cur->owner >= num_checks)
 237                 return;
 238
 239         if (pre_merge_hooks[cur->owner])
 240                 pre_merge_hooks[cur->owner](cur, other);
 241 }
 242
 243 static struct scope_hook_list *pop_scope_hook_list(struct scope_hook_stack **stack)
 244 {
 245         struct scope_hook_list *hook_list;
 246
 247         hook_list = last_ptr_list((struct ptr_list *)*stack);
 248         delete_ptr_list_last((struct ptr_list **)stack);
 249         return hook_list;
 250 }
 251
 252 static void push_scope_hook_list(struct scope_hook_stack **stack, struct scope_hook_list *list)
 253 {
 254         add_ptr_list(stack, list);
 255 }
 256
 257 void add_scope_hook(scope_hook *fn, void *data)
 258 {
 259         struct scope_hook_list *hook_list;
 260         struct scope_container *new;
 261
 262         hook_list = pop_scope_hook_list(&scope_hooks);
 263         new = __alloc_scope_container(0);
 264         new->fn = fn;
 265         new->data = data;
 266         add_ptr_list(&hook_list, new);
 267         push_scope_hook_list(&scope_hooks, hook_list);
 268 }
 269
 270 void __push_scope_hooks(void)
 271 {
 272         push_scope_hook_list(&scope_hooks, NULL);
 273 }
 274
 275 void __call_scope_hooks(void)
 276 {
 277         struct scope_hook_list *hook_list;
 278         struct scope_container *tmp;
 279
 280         hook_list = pop_scope_hook_list(&scope_hooks);
 281         FOR_EACH_PTR_REVERSE(hook_list, tmp) {
 282                 ((scope_hook *)tmp->fn)(tmp->data);
 283                 __free_scope_container(tmp);
 284         } END_FOR_EACH_PTR_REVERSE(tmp);
 285 }
 286
 287 void __free_scope_hooks(void)
 288 {
 289         struct scope_hook_list *hook_list;
 290         struct scope_container *tmp;
 291
 292         hook_list = pop_scope_hook_list(&scope_hooks);
 293         FOR_EACH_PTR_REVERSE(hook_list, tmp) {
 294                 __free_scope_container(tmp);
 295         } END_FOR_EACH_PTR_REVERSE(tmp);
 296 }
 297
 298 void __call_all_scope_hooks(void)
 299 {
 300         struct scope_hook_list *tmp_scope;
 301         struct scope_container *tmp;
 302
 303         FOR_EACH_PTR_REVERSE(scope_hooks, tmp_scope) {
 304                 FOR_EACH_PTR_REVERSE(tmp_scope, tmp) {
 305                         ((scope_hook *)tmp->fn)(tmp->data);
 306                 } END_FOR_EACH_PTR_REVERSE(tmp);
 307         } END_FOR_EACH_PTR_REVERSE(tmp_scope);
 308 }
 309
 310 void add_array_initialized_hook(void (*hook)(struct expression *array, int nr))
 311 {
 312         struct hook_container *container = __alloc_hook_container(0);
 313
 314         container->fn = hook;
 315
 316         add_ptr_list(&array_init_hooks, container);
 317 }
 318
 319 void __call_array_initialized_hooks(struct expression *array, int nr)
 320 {
 321         struct hook_container *tmp;
 322
 323         FOR_EACH_PTR(array_init_hooks, tmp) {
 324                 ((array_init_hook *)tmp->fn)(array, nr);
 325         } END_FOR_EACH_PTR(tmp);
 326 }
 327
 328 void allocate_hook_memory(void)
 329 {
 330         pre_merge_hooks = malloc(num_checks * sizeof(*pre_merge_hooks));
 331         memset(pre_merge_hooks, 0, num_checks * sizeof(*pre_merge_hooks));
 332 }
 333
 334 void register_hooks(int id)
 335 {
 336         add_function_data((unsigned long *)&scope_hooks);
 337         my_id = id;
 338 }
 339
 340 void call_void_fns(struct void_fn_list *list)
 341 {
 342         void_fn *fn;
 343
 344         FOR_EACH_PTR(list, fn) {
 345                 (fn)();
 346         } END_FOR_EACH_PTR(fn);
 347 }
 348
 349 void call_expr_fns(struct expr_fn_list *list, struct expression *expr)
 350 {
 351         expr_func *fn;
 352
 353         FOR_EACH_PTR(list, fn) {
 354                 (fn)(expr);
 355         } END_FOR_EACH_PTR(fn);
 356 }
 357
 358 void call_stmt_fns(struct stmt_fn_list *list, struct statement *stmt)
 359 {
 360         stmt_func *fn;
 361
 362         FOR_EACH_PTR(list, fn) {
 363                 (fn)(stmt);
 364         } END_FOR_EACH_PTR(fn);
 365 }
 366
 367 void call_sym_fns(struct sym_fn_list *list, struct symbol *sym)
 368 {
 369         sym_func *fn;
 370
 371         FOR_EACH_PTR(list, fn) {
 372                 (fn)(sym);
 373         } END_FOR_EACH_PTR(fn);
 374 }
 375
 376 void call_name_sym_fns(struct name_sym_fn_list *list, struct expression *expr, const char *name, struct symbol *sym)
 377 {
 378         name_sym_hook *fn;
 379
 380         FOR_EACH_PTR(list, fn) {
 381                 (fn)(expr, name, sym);
 382         } END_FOR_EACH_PTR(fn);
 383 }
 384
 385 void call_string_hooks(struct string_hook_list *list, struct expression *expr, const char *str)
 386 {
 387         string_hook *fn;
 388
 389         FOR_EACH_PTR(list, fn) {
 390                 (fn)(expr, str);
 391         } END_FOR_EACH_PTR(fn);
 392 }
 393