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 (expr_func)(struct expression *expr);
  37 typedef void (stmt_func)(struct statement *stmt);
  38 typedef void (sym_func)(struct symbol *sym);
  39 typedef void (sym_list_func)(struct symbol_list *sym_list);
  40
  41 static struct hook_func_list *merge_funcs;
  42 static struct hook_func_list *unmatched_state_funcs;
  43 static struct hook_func_list *hook_array[NUM_HOOKS] = {};
  44 static const enum data_type data_types[NUM_HOOKS] = {
  45         [EXPR_HOOK] = EXPR_PTR,
  46         [EXPR_HOOK_AFTER] = EXPR_PTR,
  47         [STMT_HOOK] = STMT_PTR,
  48         [STMT_HOOK_AFTER] = STMT_PTR,
  49         [SYM_HOOK] = EXPR_PTR,
  50         [STRING_HOOK] = EXPR_PTR,
  51         [DECLARATION_HOOK] = 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         [CONDITION_HOOK] = EXPR_PTR,
  63         [SELECT_HOOK] = EXPR_PTR,
  64         [WHOLE_CONDITION_HOOK] = EXPR_PTR,
  65         [FUNCTION_CALL_HOOK] = EXPR_PTR,
  66         [CALL_HOOK_AFTER_INLINE] = EXPR_PTR,
  67         [FUNCTION_CALL_HOOK_AFTER_DB] = EXPR_PTR,
  68         [DEREF_HOOK] = EXPR_PTR,
  69         [CASE_HOOK] = NO_DATA,
  70         [ASM_HOOK] = STMT_PTR,
  71         [CAST_HOOK] = EXPR_PTR,
  72         [SIZEOF_HOOK] = EXPR_PTR,
  73         [BASE_HOOK] = SYMBOL_PTR,
  74         [FUNC_DEF_HOOK] = SYMBOL_PTR,
  75         [AFTER_DEF_HOOK] = SYMBOL_PTR,
  76         [END_FUNC_HOOK] = SYMBOL_PTR,
  77         [AFTER_FUNC_HOOK] = SYMBOL_PTR,
  78         [RETURN_HOOK] = EXPR_PTR,
  79         [INLINE_FN_START] = EXPR_PTR,
  80         [INLINE_FN_END] = EXPR_PTR,
  81         [END_FILE_HOOK] = SYM_LIST_PTR,
  82 };
  83
  84 void (**pre_merge_hooks)(struct sm_state *cur, struct sm_state *other);
  85
  86 struct scope_container {
  87         void *fn;
  88         void *data;
  89 };
  90 ALLOCATOR(scope_container, "scope hook functions");
  91 DECLARE_PTR_LIST(scope_hook_list, struct scope_container);
  92 DECLARE_PTR_LIST(scope_hook_stack, struct scope_hook_list);
  93 static struct scope_hook_stack *scope_hooks;
  94
  95 void add_hook(void *func, enum hook_type type)
  96 {
  97         struct hook_container *container = __alloc_hook_container(0);
  98
  99         container->hook_type = type;
 100         container->fn = func;
 101
 102         add_ptr_list(&hook_array[type], container);
 103 }
 104
 105 void add_merge_hook(int client_id, merge_func_t *func)
 106 {
 107         struct hook_container *container = __alloc_hook_container(0);
 108         container->owner = client_id;
 109         container->fn = func;
 110         add_ptr_list(&merge_funcs, container);
 111 }
 112
 113 void add_unmatched_state_hook(int client_id, unmatched_func_t *func)
 114 {
 115         struct hook_container *container = __alloc_hook_container(0);
 116         container->owner = client_id;
 117         container->fn = func;
 118         add_ptr_list(&unmatched_state_funcs, container);
 119 }
 120
 121 void add_pre_merge_hook(int client_id, void (*hook)(struct sm_state *cur, struct sm_state *other))
 122 {
 123         pre_merge_hooks[client_id] = hook;
 124 }
 125
 126 static void pass_expr_to_client(void *fn, void *data)
 127 {
 128         ((expr_func *)fn)((struct expression *)data);
 129 }
 130
 131 static void pass_stmt_to_client(void *fn, void *data)
 132 {
 133         ((stmt_func *)fn)((struct statement *)data);
 134 }
 135
 136 static void pass_sym_to_client(void *fn, void *data)
 137 {
 138         ((sym_func *)fn)((struct symbol *)data);
 139 }
 140
 141 static void pass_sym_list_to_client(void *fn, void *data)
 142 {
 143         ((sym_list_func *)fn)((struct symbol_list *)data);
 144 }
 145
 146 void __pass_to_client(void *data, enum hook_type type)
 147 {
 148         struct hook_container *container;
 149
 150         FOR_EACH_PTR(hook_array[type], container) {
 151                 switch (data_types[type]) {
 152                 case EXPR_PTR:
 153                         pass_expr_to_client(container->fn, data);
 154                         break;
 155                 case STMT_PTR:
 156                         pass_stmt_to_client(container->fn, data);
 157                         break;
 158                 case SYMBOL_PTR:
 159                         pass_sym_to_client(container->fn, data);
 160                         break;
 161                 case SYM_LIST_PTR:
 162                         pass_sym_list_to_client(container->fn, data);
 163                         break;
 164                 }
 165         } END_FOR_EACH_PTR(container);
 166 }
 167
 168 void __pass_case_to_client(struct expression *switch_expr,
 169                            struct range_list *rl)
 170 {
 171         typedef void (case_func)(struct expression *switch_expr,
 172                                  struct range_list *rl);
 173         struct hook_container *container;
 174
 175         FOR_EACH_PTR(hook_array[CASE_HOOK], container) {
 176                 ((case_func *)container->fn)(switch_expr, rl);
 177         } END_FOR_EACH_PTR(container);
 178 }
 179
 180 int __has_merge_function(int client_id)
 181 {
 182         struct hook_container *tmp;
 183
 184         FOR_EACH_PTR(merge_funcs, tmp) {
 185                 if (tmp->owner == client_id)
 186                         return 1;
 187         } END_FOR_EACH_PTR(tmp);
 188         return 0;
 189 }
 190
 191 struct smatch_state *__client_merge_function(int owner,
 192                                              struct smatch_state *s1,
 193                                              struct smatch_state *s2)
 194 {
 195         struct smatch_state *tmp_state;
 196         struct hook_container *tmp;
 197
 198         /* Pass NULL states first and the rest alphabetically by name */
 199         if (!s2 || (s1 && strcmp(s2->name, s1->name) < 0)) {
 200                 tmp_state = s1;
 201                 s1 = s2;
 202                 s2 = tmp_state;
 203         }
 204
 205         FOR_EACH_PTR(merge_funcs, tmp) {
 206                 if (tmp->owner == owner)
 207                         return ((merge_func_t *)tmp->fn)(s1, s2);
 208         } END_FOR_EACH_PTR(tmp);
 209         return &undefined;
 210 }
 211
 212 struct smatch_state *__client_unmatched_state_function(struct sm_state *sm)
 213 {
 214         struct hook_container *tmp;
 215
 216         FOR_EACH_PTR(unmatched_state_funcs, tmp) {
 217                 if (tmp->owner == sm->owner)
 218                         return ((unmatched_func_t *)tmp->fn)(sm);
 219         } END_FOR_EACH_PTR(tmp);
 220         return &undefined;
 221 }
 222
 223 void call_pre_merge_hook(struct sm_state *cur, struct sm_state *other)
 224 {
 225         if (cur->owner >= num_checks)
 226                 return;
 227
 228         if (pre_merge_hooks[cur->owner])
 229                 pre_merge_hooks[cur->owner](cur, other);
 230 }
 231
 232 static struct scope_hook_list *pop_scope_hook_list(struct scope_hook_stack **stack)
 233 {
 234         struct scope_hook_list *hook_list;
 235
 236         hook_list = last_ptr_list((struct ptr_list *)*stack);
 237         delete_ptr_list_last((struct ptr_list **)stack);
 238         return hook_list;
 239 }
 240
 241 static void push_scope_hook_list(struct scope_hook_stack **stack, struct scope_hook_list *l)
 242 {
 243         add_ptr_list(stack, l);
 244 }
 245
 246 void add_scope_hook(scope_hook *fn, void *data)
 247 {
 248         struct scope_hook_list *hook_list;
 249         struct scope_container *new;
 250
 251         if (!scope_hooks)
 252                 return;
 253         hook_list = pop_scope_hook_list(&scope_hooks);
 254         new = __alloc_scope_container(0);
 255         new->fn = fn;
 256         new->data = data;
 257         add_ptr_list(&hook_list, new);
 258         push_scope_hook_list(&scope_hooks, hook_list);
 259 }
 260
 261 void __push_scope_hooks(void)
 262 {
 263         push_scope_hook_list(&scope_hooks, NULL);
 264 }
 265
 266 void __call_scope_hooks(void)
 267 {
 268         struct scope_hook_list *hook_list;
 269         struct scope_container *tmp;
 270
 271         if (!scope_hooks)
 272                 return;
 273
 274         hook_list = pop_scope_hook_list(&scope_hooks);
 275         FOR_EACH_PTR(hook_list, tmp) {
 276                 ((scope_hook *)tmp->fn)(tmp->data);
 277                 __free_scope_container(tmp);
 278         } END_FOR_EACH_PTR(tmp);
 279 }
 280
 281 void allocate_hook_memory(void)
 282 {
 283         pre_merge_hooks = malloc(num_checks * sizeof(*pre_merge_hooks));
 284         memset(pre_merge_hooks, 0, num_checks * sizeof(*pre_merge_hooks));
 285 }
 286