smatch_hooks.c

   1 /*
   2  * sparse/smatch_hooks.c
   3  *
   4  * Copyright (C) 2006 Dan Carpenter.
   5  *
   6  *  Licensed under the Open Software License version 1.1
   7  *
   8  */
   9
  10 #include "smatch.h"
  11
  12 enum data_type {
  13         EXPR_PTR,
  14         STMT_PTR,
  15         SYMBOL_PTR,
  16         SYM_LIST_PTR,
  17 };
  18
  19 struct hook_container {
  20         int hook_type;
  21         enum data_type data_type;
  22         void *fn;
  23 };
  24 ALLOCATOR(hook_container, "hook functions");
  25 DECLARE_PTR_LIST(hook_func_list, struct hook_container);
  26 static struct hook_func_list *hook_funcs;
  27 static struct hook_func_list *merge_funcs;
  28 static struct hook_func_list *unmatched_state_funcs;
  29
  30 struct scope_container {
  31         void *fn;
  32         void *data;
  33 };
  34 ALLOCATOR(scope_container, "scope hook functions");
  35 DECLARE_PTR_LIST(scope_hook_list, struct scope_container);
  36 DECLARE_PTR_LIST(scope_hook_stack, struct scope_hook_list);
  37 static struct scope_hook_stack *scope_hooks;
  38
  39 void add_hook(void *func, enum hook_type type)
  40 {
  41         struct hook_container *container = __alloc_hook_container(0);
  42         container->hook_type = type;
  43         container->fn = func;
  44         switch (type) {
  45         case EXPR_HOOK:
  46                 container->data_type = EXPR_PTR;
  47                 break;
  48         case STMT_HOOK:
  49                 container->data_type = STMT_PTR;
  50                 break;
  51         case STMT_HOOK_AFTER:
  52                 container->data_type = STMT_PTR;
  53                 break;
  54         case SYM_HOOK:
  55                 container->data_type = EXPR_PTR;
  56                 break;
  57         case STRING_HOOK:
  58                 container->data_type = EXPR_PTR;
  59                 break;
  60         case DECLARATION_HOOK:
  61                 container->data_type = SYMBOL_PTR;
  62                 break;
  63         case ASSIGNMENT_HOOK:
  64                 container->data_type = EXPR_PTR;
  65                 break;
  66         case RAW_ASSIGNMENT_HOOK:
  67                 container->data_type = EXPR_PTR;
  68                 break;
  69         case GLOBAL_ASSIGNMENT_HOOK:
  70                 container->data_type = EXPR_PTR;
  71                 break;
  72         case CALL_ASSIGNMENT_HOOK:
  73                 container->data_type = EXPR_PTR;
  74                 break;
  75         case MACRO_ASSIGNMENT_HOOK:
  76                 container->data_type = EXPR_PTR;
  77                 break;
  78         case BINOP_HOOK:
  79                 container->data_type = EXPR_PTR;
  80                 break;
  81         case OP_HOOK:
  82                 container->data_type = EXPR_PTR;
  83                 break;
  84         case LOGIC_HOOK:
  85                 container->data_type = EXPR_PTR;
  86                 break;
  87         case PRELOOP_HOOK:
  88                 container->data_type = STMT_PTR;
  89                 break;
  90         case CONDITION_HOOK:
  91                 container->data_type = EXPR_PTR;
  92                 break;
  93         case SELECT_HOOK:
  94                 container->data_type = EXPR_PTR;
  95                 break;
  96         case WHOLE_CONDITION_HOOK:
  97                 container->data_type = EXPR_PTR;
  98                 break;
  99         case FUNCTION_CALL_HOOK:
 100                 container->data_type = EXPR_PTR;
 101                 break;
 102         case CALL_HOOK_AFTER_INLINE:
 103                 container->data_type = EXPR_PTR;
 104                 break;
 105         case DEREF_HOOK:
 106                 container->data_type = EXPR_PTR;
 107                 break;
 108         case CASE_HOOK:
 109                 /* nothing needed */
 110                 break;
 111         case ASM_HOOK:
 112                 container->data_type = STMT_PTR;
 113                 break;
 114         case CAST_HOOK:
 115                 container->data_type = EXPR_PTR;
 116                 break;
 117         case SIZEOF_HOOK:
 118                 container->data_type = EXPR_PTR;
 119                 break;
 120         case BASE_HOOK:
 121                 container->data_type = SYMBOL_PTR;
 122                 break;
 123         case FUNC_DEF_HOOK:
 124                 container->data_type = SYMBOL_PTR;
 125                 break;
 126         case AFTER_DEF_HOOK:
 127                 container->data_type = SYMBOL_PTR;
 128                 break;
 129         case END_FUNC_HOOK:
 130                 container->data_type = SYMBOL_PTR;
 131                 break;
 132         case AFTER_FUNC_HOOK:
 133                 container->data_type = SYMBOL_PTR;
 134                 break;
 135         case RETURN_HOOK:
 136                 container->data_type = EXPR_PTR;
 137                 break;
 138         case INLINE_FN_START:
 139                 container->data_type = EXPR_PTR;
 140                 break;
 141         case INLINE_FN_END:
 142                 container->data_type = EXPR_PTR;
 143                 break;
 144         case END_FILE_HOOK:
 145                 container->data_type = SYM_LIST_PTR;
 146                 break;
 147         }
 148         add_ptr_list(&hook_funcs, container);
 149 }
 150
 151 void add_merge_hook(int client_id, merge_func_t *func)
 152 {
 153         struct hook_container *container = __alloc_hook_container(0);
 154         container->data_type = client_id;
 155         container->fn = func;
 156         add_ptr_list(&merge_funcs, container);
 157 }
 158
 159 void add_unmatched_state_hook(int client_id, unmatched_func_t *func)
 160 {
 161         struct hook_container *container = __alloc_hook_container(0);
 162         container->data_type = client_id;
 163         container->fn = func;
 164         add_ptr_list(&unmatched_state_funcs, container);
 165 }
 166
 167 static void pass_to_client(void *fn)
 168 {
 169         typedef void (expr_func)();
 170         ((expr_func *) fn)();
 171 }
 172
 173 static void pass_expr_to_client(void *fn, void *data)
 174 {
 175         typedef void (expr_func)(struct expression *expr);
 176         ((expr_func *) fn)((struct expression *) data);
 177 }
 178
 179 static void pass_stmt_to_client(void *fn, void *data)
 180 {
 181         typedef void (stmt_func)(struct statement *stmt);
 182         ((stmt_func *) fn)((struct statement *) data);
 183 }
 184
 185 static void pass_sym_to_client(void *fn, void *data)
 186 {
 187         typedef void (sym_func)(struct symbol *sym);
 188         ((sym_func *) fn)((struct symbol *) data);
 189 }
 190
 191 static void pass_sym_list_to_client(void *fn, void *data)
 192 {
 193         typedef void (sym_func)(struct symbol_list *sym_list);
 194         ((sym_func *) fn)((struct symbol_list *) data);
 195 }
 196
 197 void __pass_to_client(void *data, enum hook_type type)
 198 {
 199         struct hook_container *container;
 200
 201         FOR_EACH_PTR(hook_funcs, container) {
 202                 if (container->hook_type == type) {
 203                         switch (container->data_type) {
 204                         case EXPR_PTR:
 205                                 pass_expr_to_client(container->fn, data);
 206                                 break;
 207                         case STMT_PTR:
 208                                 pass_stmt_to_client(container->fn, data);
 209                                 break;
 210                         case SYMBOL_PTR:
 211                                 pass_sym_to_client(container->fn, data);
 212                                 break;
 213                         case SYM_LIST_PTR:
 214                                 pass_sym_list_to_client(container->fn, data);
 215                                 break;
 216                         }
 217                 }
 218         } END_FOR_EACH_PTR(container);
 219 }
 220
 221 void __pass_to_client_no_data(enum hook_type type)
 222 {
 223         struct hook_container *container;
 224
 225         FOR_EACH_PTR(hook_funcs, container) {
 226                 if (container->hook_type == type)
 227                         pass_to_client(container->fn);
 228         } END_FOR_EACH_PTR(container);
 229 }
 230
 231 void __pass_case_to_client(struct expression *switch_expr,
 232                            struct expression *case_expr)
 233 {
 234         typedef void (case_func)(struct expression *switch_expr,
 235                                  struct expression *case_expr);
 236         struct hook_container *container;
 237
 238         FOR_EACH_PTR(hook_funcs, container) {
 239                 if (container->hook_type == CASE_HOOK)
 240                         ((case_func *) container->fn)(switch_expr, case_expr);
 241         } END_FOR_EACH_PTR(container);
 242 }
 243
 244 int __has_merge_function(int client_id)
 245 {
 246         struct hook_container *tmp;
 247
 248         FOR_EACH_PTR(merge_funcs, tmp) {
 249                 if (tmp->data_type == client_id)
 250                         return 1;
 251         } END_FOR_EACH_PTR(tmp);
 252         return 0;
 253 }
 254
 255 struct smatch_state *__client_merge_function(int owner,
 256                                              struct smatch_state *s1,
 257                                              struct smatch_state *s2)
 258 {
 259         struct smatch_state *tmp_state;
 260         struct hook_container *tmp;
 261
 262         /* Pass NULL states first and the rest alphabetically by name */
 263         if (!s2 || (s1 && strcmp(s2->name, s1->name) < 0)) {
 264                 tmp_state = s1;
 265                 s1 = s2;
 266                 s2 = tmp_state;
 267         }
 268
 269         FOR_EACH_PTR(merge_funcs, tmp) {
 270                 if (tmp->data_type == owner)
 271                         return ((merge_func_t *) tmp->fn)(s1, s2);
 272         } END_FOR_EACH_PTR(tmp);
 273         return &undefined;
 274 }
 275
 276 struct smatch_state *__client_unmatched_state_function(struct sm_state *sm)
 277 {
 278         struct hook_container *tmp;
 279
 280         FOR_EACH_PTR(unmatched_state_funcs, tmp) {
 281                 if (tmp->data_type == sm->owner)
 282                         return ((unmatched_func_t *) tmp->fn)(sm);
 283         } END_FOR_EACH_PTR(tmp);
 284         return &undefined;
 285 }
 286
 287 static struct scope_hook_list *pop_scope_hook_list(struct scope_hook_stack **stack)
 288 {
 289         struct scope_hook_list *hook_list;
 290
 291         hook_list = last_ptr_list((struct ptr_list *)*stack);
 292         delete_ptr_list_last((struct ptr_list **)stack);
 293         return hook_list;
 294 }
 295
 296 static void push_scope_hook_list(struct scope_hook_stack **stack, struct scope_hook_list *l)
 297 {
 298         add_ptr_list(stack, l);
 299 }
 300
 301 void add_scope_hook(scope_hook *fn, void *data)
 302 {
 303         struct scope_hook_list *hook_list;
 304         struct scope_container *new;
 305
 306         if (!scope_hooks)
 307                 return;
 308         hook_list = pop_scope_hook_list(&scope_hooks);
 309         new = __alloc_scope_container(0);
 310         new->fn = fn;
 311         new->data = data;
 312         add_ptr_list(&hook_list, new);
 313         push_scope_hook_list(&scope_hooks, hook_list);
 314 }
 315
 316 void __push_scope_hooks(void)
 317 {
 318         push_scope_hook_list(&scope_hooks, NULL);
 319 }
 320
 321 void __call_scope_hooks(void)
 322 {
 323         struct scope_hook_list *hook_list;
 324         struct scope_container *tmp;
 325
 326         if (!scope_hooks)
 327                 return;
 328
 329         hook_list = pop_scope_hook_list(&scope_hooks);
 330         FOR_EACH_PTR(hook_list, tmp) {
 331                 ((scope_hook *) tmp->fn)(tmp->data);
 332                 __free_scope_container(tmp);
 333         } END_FOR_EACH_PTR(tmp);
 334 }