smatch_function_hooks.c

   1 #define _GNU_SOURCE
   2 #include <search.h>
   3 #include <stdlib.h>
   4 #include <stdio.h>
   5 #include "smatch.h"
   6 #include "smatch_slist.h"
   7 #include "smatch_extra.h"
   8
   9 ALLOCATOR(fcall_back, "call backs");
  10
  11 static struct hsearch_data func_hash;
  12
  13 static struct state_list *cond_true = NULL;
  14 static struct state_list *cond_false = NULL;
  15 static int in_hook = 0;
  16 #define REGULAR_CALL 0
  17 #define CONDITIONAL_CALL 1
  18 #define ASSIGN_CALL 2
  19
  20 static struct fcall_back *alloc_fcall_back(int type, func_hook *call_back,
  21                                            void *info)
  22 {
  23         struct fcall_back *cb;
  24
  25         cb = __alloc_fcall_back(0);
  26         cb->type = type;
  27         cb->call_back = call_back;
  28         cb->info = info;
  29         return cb;
  30 }
  31
  32 static struct call_back_list *get_call_backs(const char *look_for)
  33 {
  34         ENTRY e, *ep;
  35
  36         e.key = (char *)look_for;
  37         hsearch_r(e, FIND, &ep, &func_hash);
  38         if (!ep)
  39                 return NULL;
  40         return (struct call_back_list *)ep->data;
  41 }
  42
  43 static void add_cb_hook(const char *look_for, struct fcall_back *cb)
  44 {
  45         ENTRY e, *ep;
  46         char *old_key = NULL;
  47
  48         e.key = alloc_string(look_for);
  49         hsearch_r(e, FIND, &ep, &func_hash);
  50         if (!ep) {
  51                 struct call_back_list *list = NULL;
  52
  53                 add_ptr_list(&list, cb);
  54                 e.data = list;
  55         } else {
  56                 old_key = e.key;
  57                 e.key = ep->key;
  58                 add_ptr_list((struct call_back_list **)&ep->data, cb);
  59                 e.data = ep->data;
  60         }
  61         if (!hsearch_r(e, ENTER, &ep, &func_hash)) {
  62                 printf("Error hash table too small in smatch_function_hooks.c\n");
  63                 exit(1);
  64         }
  65         free_string(old_key);
  66 }
  67
  68 void add_function_hook(const char *look_for, func_hook *call_back, void *info)
  69 {
  70         struct fcall_back *cb;
  71
  72         cb = alloc_fcall_back(REGULAR_CALL, call_back, info);
  73         add_cb_hook(look_for, cb);
  74 }
  75
  76 void add_conditional_hook(const char *look_for, func_hook *call_back,
  77                           void *info)
  78 {
  79         struct fcall_back *cb;
  80
  81         cb = alloc_fcall_back(CONDITIONAL_CALL, call_back, info);
  82         add_cb_hook(look_for, cb);
  83 }
  84
  85 void add_function_assign_hook(const char *look_for, func_hook *call_back,
  86                               void *info)
  87 {
  88         struct fcall_back *cb;
  89
  90         cb = alloc_fcall_back(ASSIGN_CALL, call_back, info);
  91         add_cb_hook(look_for, cb);
  92 }
  93
  94 static void call_call_backs(struct call_back_list *list, int type,
  95                             const char *fn, struct expression *expr)
  96 {
  97         struct fcall_back *tmp;
  98
  99         FOR_EACH_PTR(list, tmp) {
 100                 if (tmp->type == type)
 101                         (tmp->call_back)(fn, expr, tmp->info);
 102         } END_FOR_EACH_PTR(tmp);
 103 }
 104
 105 static void match_function_call(struct expression *expr)
 106 {
 107         struct call_back_list *call_backs;
 108
 109         if (expr->fn->type != EXPR_SYMBOL || !expr->fn->symbol)
 110                 return;
 111         call_backs = get_call_backs(expr->fn->symbol->ident->name);
 112         if (!call_backs)
 113                 return;
 114         call_call_backs(call_backs, REGULAR_CALL, expr->fn->symbol->ident->name,
 115                         expr);
 116 }
 117
 118 static void assign_condition_funcs(const char *fn, struct expression *expr,
 119                                  struct call_back_list *call_backs)
 120 {
 121         struct fcall_back *tmp;
 122         struct sm_state *sm;
 123         int conditional = 0;
 124         char *var_name;
 125         struct symbol *sym;
 126         struct smatch_state *zero_state, *non_zero_state;
 127
 128         var_name = get_variable_from_expr(expr->left, &sym);
 129         if (!var_name || !sym)
 130                 goto free;
 131
 132         in_hook = 1;
 133         FOR_EACH_PTR(call_backs, tmp) {
 134                 if (tmp->type != CONDITIONAL_CALL)
 135                         continue;
 136
 137                 conditional = 1;
 138                 (tmp->call_back)(fn, expr->right, tmp->info);
 139         } END_FOR_EACH_PTR(tmp);
 140         if (conditional) {
 141                 zero_state = alloc_extra_state(0);
 142                 non_zero_state = add_filter(extra_undefined(), 0);
 143                 set_cond_states(var_name, SMATCH_EXTRA, sym, non_zero_state, zero_state);
 144         }
 145         in_hook = 0;
 146
 147         if (!conditional)
 148                 goto free;
 149
 150         merge_slist(&cond_true, cond_false);
 151
 152         FOR_EACH_PTR(cond_true, sm) {
 153                 __set_state(sm);
 154         } END_FOR_EACH_PTR(sm);
 155         free_slist(&cond_true);
 156         free_slist(&cond_false);
 157 free:
 158         free_string(var_name);
 159
 160 }
 161
 162 void __match_initializer_call(struct symbol *sym)
 163 {
 164         struct call_back_list *call_backs;
 165         struct expression *initializer = sym->initializer;
 166         struct expression *e_assign, *e_symbol;
 167         const char *fn;
 168
 169         if (initializer->fn->type != EXPR_SYMBOL
 170             || !initializer->fn->symbol)
 171                 return;
 172         fn = initializer->fn->symbol->ident->name;
 173         call_backs = get_call_backs(fn);
 174         if (!call_backs)
 175                 return;
 176
 177         e_assign = alloc_expression(initializer->pos, EXPR_ASSIGNMENT);
 178         e_symbol = alloc_expression(initializer->pos, EXPR_SYMBOL);
 179         e_symbol->symbol = sym;
 180         e_symbol->symbol_name = sym->ident;
 181         e_assign->left = e_symbol;
 182         e_assign->right = initializer;
 183         call_call_backs(call_backs, ASSIGN_CALL, fn, e_assign);
 184         assign_condition_funcs(fn, e_assign, call_backs);
 185 }
 186
 187 static void match_assign_call(struct expression *expr)
 188 {
 189         struct call_back_list *call_backs;
 190         const char *fn;
 191
 192         if (expr->right->fn->type != EXPR_SYMBOL || !expr->right->fn->symbol)
 193                 return;
 194         fn = expr->right->fn->symbol->ident->name;
 195         call_backs = get_call_backs(fn);
 196         if (!call_backs)
 197                 return;
 198         call_call_backs(call_backs, ASSIGN_CALL, fn, expr);
 199         assign_condition_funcs(fn, expr, call_backs);
 200 }
 201
 202 static void match_conditional_call(struct expression *expr)
 203 {
 204         struct call_back_list *call_backs;
 205         struct fcall_back *tmp;
 206         struct sm_state *sm;
 207         const char *fn;
 208
 209         if (expr->type != EXPR_CALL)
 210                 return;
 211
 212         if (expr->fn->type != EXPR_SYMBOL || !expr->fn->symbol)
 213                 return;
 214
 215         fn = expr->fn->symbol->ident->name;
 216         call_backs = get_call_backs(fn);
 217         if (!call_backs)
 218                 return;
 219         in_hook = 1;
 220         FOR_EACH_PTR(call_backs, tmp) {
 221                 if (tmp->type != CONDITIONAL_CALL)
 222                         continue;
 223
 224                 (tmp->call_back)(fn, expr, tmp->info);
 225
 226                 FOR_EACH_PTR(cond_true, sm) {
 227                         __set_true_false_sm(sm, NULL);
 228                 } END_FOR_EACH_PTR(sm);
 229                 free_slist(&cond_true);
 230
 231                 FOR_EACH_PTR(cond_false, sm) {
 232                         __set_true_false_sm(NULL, sm);
 233                 } END_FOR_EACH_PTR(sm);
 234                 free_slist(&cond_false);
 235
 236         } END_FOR_EACH_PTR(tmp);
 237         in_hook = 0;
 238 }
 239
 240 void set_cond_states(const char *name, int owner, struct symbol *sym,
 241                      struct smatch_state *true_state,
 242                      struct smatch_state *false_state)
 243 {
 244         if (!in_hook) {
 245                 printf("Error:  call set_true_false_states() not"
 246                        "set_cond_states()\n");
 247                 return;
 248         }
 249
 250         if (debug_states) {
 251                 struct smatch_state *tmp;
 252
 253                 tmp = get_state(name, owner, sym);
 254                 SM_DEBUG("%d set_true_false '%s'.  Was %s.  Now T:%s F:%s\n",
 255                          get_lineno(), name, show_state(tmp),
 256                          show_state(true_state), show_state(false_state));
 257         }
 258
 259         if (true_state) {
 260                 set_state_slist(&cond_true, name, owner, sym, true_state);
 261         }
 262         if (false_state)
 263                 set_state_slist(&cond_false, name, owner, sym, false_state);
 264 }
 265
 266 void create_function_hash(void)
 267 {
 268         hcreate_r(10000, &func_hash);  // Apparently 1000 is too few...
 269 }
 270
 271 void register_function_hooks(int id)
 272 {
 273         add_hook(&match_function_call, FUNCTION_CALL_HOOK);
 274         add_hook(&match_assign_call, CALL_ASSIGNMENT_HOOK);
 275         add_hook(&match_conditional_call, CONDITION_HOOK);
 276 }