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