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 struct hook_container {
  13         int hook_type;
  14         int data_type;
  15         void * fn;
  16 };
  17 ALLOCATOR(hook_container, "hook functions");
  18 DECLARE_PTR_LIST(hook_func_list, struct hook_container);
  19 static struct hook_func_list *hook_funcs;
  20 static struct hook_func_list *merge_funcs;
  21 static struct hook_func_list *unmatched_state_funcs;
  22
  23 void add_hook(void *func, enum hook_type type)
  24 {
  25         struct hook_container *container = __alloc_hook_container(0);
  26         container->hook_type = type;
  27         container->fn = func;
  28         switch(type) {
  29         case EXPR_HOOK:
  30                 container->data_type = EXPR_HOOK;
  31                 break;
  32         case STMT_HOOK:
  33                 container->data_type = STMT_HOOK;
  34                 break;
  35         case SYM_HOOK:
  36                 container->data_type = SYM_HOOK;
  37                 break;
  38         case DECLARATION_HOOK:
  39                 container->data_type = SYM_HOOK;
  40                 break;
  41         case ASSIGNMENT_HOOK:
  42                 container->data_type = EXPR_HOOK;
  43                 break;
  44         case CALL_ASSIGNMENT_HOOK:
  45                 container->data_type = EXPR_HOOK;
  46                 break;
  47         case OP_HOOK:
  48                 container->data_type = EXPR_HOOK;
  49                 break;
  50         case CONDITION_HOOK:
  51                 container->data_type = EXPR_HOOK;
  52                 break;
  53         case WHOLE_CONDITION_HOOK:
  54                 container->data_type = EXPR_HOOK;
  55                 break;
  56         case FUNCTION_CALL_HOOK:
  57                 container->data_type = EXPR_HOOK;
  58                 break;
  59         case DEREF_HOOK:
  60                 container->data_type = EXPR_HOOK;
  61                 break;
  62         case CASE_HOOK:
  63                 /* nothing needed */
  64                 break;
  65         case BASE_HOOK:
  66                 container->data_type = SYM_HOOK;
  67                 break;
  68         case FUNC_DEF_HOOK:
  69                 container->data_type = SYM_HOOK;
  70                 break;
  71         case END_FUNC_HOOK:
  72                 container->data_type = SYM_HOOK;
  73                 break;
  74         case RETURN_HOOK:
  75                 container->data_type = STMT_HOOK;
  76                 break;
  77         case END_FILE_HOOK:
  78                 /* nothing needed... */
  79                 break;
  80         }
  81         add_ptr_list(&hook_funcs, container);
  82 }
  83
  84 void add_merge_hook(int client_id, merge_func_t *func)
  85 {
  86         struct hook_container *container = __alloc_hook_container(0);
  87         container->data_type = client_id;
  88         container->fn = func;
  89         add_ptr_list(&merge_funcs, container);
  90 }
  91
  92 void add_unmatched_state_hook(int client_id, unmatched_func_t *func)
  93 {
  94         struct hook_container *container = __alloc_hook_container(0);
  95         container->data_type = client_id;
  96         container->fn = func;
  97         add_ptr_list(&unmatched_state_funcs, container);
  98 }
  99
 100 static void pass_to_client(void * fn)
 101 {
 102         typedef void (expr_func)();
 103         ((expr_func *) fn)();
 104 }
 105
 106 static void pass_expr_to_client(void * fn, void * data)
 107 {
 108         typedef void (expr_func)(struct expression *expr);
 109         ((expr_func *) fn)((struct expression *) data);
 110 }
 111
 112 static void pass_stmt_to_client(void * fn, void * data)
 113 {
 114         typedef void (stmt_func)(struct statement *stmt);
 115         ((stmt_func *) fn)((struct statement *) data);
 116 }
 117
 118 static void pass_sym_to_client(void * fn, void * data)
 119 {
 120         typedef void (sym_func)(struct symbol *sym);
 121         ((sym_func *) fn)((struct symbol *) data);
 122 }
 123
 124 void __pass_to_client(void *data, enum hook_type type)
 125 {
 126         struct hook_container *container;
 127
 128         if (!data)
 129                 return;
 130
 131         FOR_EACH_PTR(hook_funcs, container) {
 132                 if (container->hook_type == type) {
 133                         switch(container->data_type) {
 134                         case EXPR_HOOK:
 135                                 pass_expr_to_client(container->fn, data);
 136                                 break;
 137                         case STMT_HOOK:
 138                                 pass_stmt_to_client(container->fn, data);
 139                                 break;
 140                         case SYM_HOOK:
 141                                 pass_sym_to_client(container->fn, data);
 142                                 break;
 143                         }
 144                 }
 145         } END_FOR_EACH_PTR(container);
 146 }
 147
 148 void __pass_to_client_no_data(enum hook_type type)
 149 {
 150         struct hook_container *container;
 151
 152         FOR_EACH_PTR(hook_funcs, container) {
 153                 if (container->hook_type == type)
 154                         pass_to_client(container->fn);
 155         } END_FOR_EACH_PTR(container);
 156 }
 157
 158 void __pass_case_to_client(struct expression *switch_expr,
 159                            struct expression *case_expr)
 160 {
 161         typedef void (case_func)(struct expression *switch_expr,
 162                                  struct expression *case_expr);
 163         struct hook_container *container;
 164
 165         FOR_EACH_PTR(hook_funcs, container) {
 166                 if (container->hook_type == CASE_HOOK) {
 167                         ((case_func *) container->fn)(switch_expr, case_expr);
 168                 }
 169         } END_FOR_EACH_PTR(container);
 170 }
 171
 172 int __has_merge_function(int client_id)
 173 {
 174         struct hook_container *tmp;
 175
 176         FOR_EACH_PTR(merge_funcs, tmp) {
 177                 if (tmp->data_type == client_id)
 178                         return 1;
 179         } END_FOR_EACH_PTR(tmp);
 180         return 0;
 181 }
 182
 183 struct smatch_state *__client_merge_function(int owner, const char *name,
 184                                              struct symbol *sym,
 185                                              struct smatch_state *s1,
 186                                              struct smatch_state *s2)
 187 {
 188         struct smatch_state *tmp_state;
 189         struct hook_container *tmp;
 190
 191         /* Pass NULL states first and the rest alphabetically by name */
 192         if (!s2 || (s1 && strcmp(s2->name, s1->name) < 0)) {
 193                 tmp_state = s1;
 194                 s1 = s2;
 195                 s2 = tmp_state;
 196         }
 197
 198         FOR_EACH_PTR(merge_funcs, tmp) {
 199                 if (tmp->data_type == owner)
 200                         return ((merge_func_t *) tmp->fn)(name, sym, s1, s2);
 201         } END_FOR_EACH_PTR(tmp);
 202         return &undefined;
 203 }
 204
 205 struct smatch_state *__client_unmatched_state_function(struct sm_state *sm)
 206 {
 207         struct hook_container *tmp;
 208
 209         FOR_EACH_PTR(unmatched_state_funcs, tmp) {
 210                 if (tmp->data_type == sm->owner)
 211                         return ((unmatched_func_t *) tmp->fn)(sm);
 212         } END_FOR_EACH_PTR(tmp);
 213         return &undefined;
 214 }