smatch_function_hooks.c

   1 /*
   2  * sparse/smatch_function_hooks.c
   3  *
   4  * Copyright (C) 2009 Dan Carpenter.
   5  *
   6  * Licensed under the Open Software License version 1.1
   7  *
   8  */
   9
  10 /*
  11  * There are three types of function hooks:
  12  * add_function_hook()        - For any time a function is called.
  13  * add_function_assign_hook() - foo = the_function().
  14  * add_macro_assign_hook()    - foo = the_macro().
  15  * return_implies_state()     - For when a return value of 1 implies locked
  16  *                              and 0 implies unlocked. etc. etc.
  17  *
  18  */
  19
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include "smatch.h"
  23 #include "smatch_slist.h"
  24 #include "smatch_extra.h"
  25 #include "smatch_function_hashtable.h"
  26
  27 struct fcall_back {
  28         int type;
  29         struct data_range *range;
  30         func_hook *call_back;
  31         void *info;
  32 };
  33
  34 ALLOCATOR(fcall_back, "call backs");
  35 DECLARE_PTR_LIST(call_back_list, struct fcall_back);
  36
  37 DEFINE_FUNCTION_HASHTABLE_STATIC(callback, struct fcall_back, struct call_back_list);
  38 static struct hashtable *func_hash;
  39
  40 #define REGULAR_CALL     0
  41 #define ASSIGN_CALL      1
  42 #define RANGED_CALL      2
  43 #define MACRO_ASSIGN     3
  44
  45 static struct fcall_back *alloc_fcall_back(int type, func_hook *call_back,
  46                                            void *info)
  47 {
  48         struct fcall_back *cb;
  49
  50         cb = __alloc_fcall_back(0);
  51         cb->type = type;
  52         cb->call_back = call_back;
  53         cb->info = info;
  54         return cb;
  55 }
  56
  57 void add_function_hook(const char *look_for, func_hook *call_back, void *info)
  58 {
  59         struct fcall_back *cb;
  60
  61         cb = alloc_fcall_back(REGULAR_CALL, call_back, info);
  62         add_callback(func_hash, look_for, cb);
  63 }
  64
  65 void add_function_assign_hook(const char *look_for, func_hook *call_back,
  66                               void *info)
  67 {
  68         struct fcall_back *cb;
  69
  70         cb = alloc_fcall_back(ASSIGN_CALL, call_back, info);
  71         add_callback(func_hash, look_for, cb);
  72 }
  73
  74 void add_macro_assign_hook(const char *look_for, func_hook *call_back,
  75                         void *info)
  76 {
  77         struct fcall_back *cb;
  78
  79         cb = alloc_fcall_back(MACRO_ASSIGN, call_back, info);
  80         add_callback(func_hash, look_for, cb);
  81 }
  82
  83 void return_implies_state(const char *look_for, long long start, long long end,
  84                          implication_hook *call_back, void *info)
  85 {
  86         struct fcall_back *cb;
  87
  88         cb = alloc_fcall_back(RANGED_CALL, (func_hook *)call_back, info);
  89         cb->range = alloc_range_perm(start, end);
  90         add_callback(func_hash, look_for, cb);
  91 }
  92
  93 static void call_call_backs(struct call_back_list *list, int type,
  94                             const char *fn, struct expression *expr)
  95 {
  96         struct fcall_back *tmp;
  97
  98         FOR_EACH_PTR(list, tmp) {
  99                 if (tmp->type == type)
 100                         (tmp->call_back)(fn, expr, tmp->info);
 101         } END_FOR_EACH_PTR(tmp);
 102 }
 103
 104 static void call_ranged_call_backs(struct call_back_list *list,
 105                                 const char *fn, struct expression *call_expr,
 106                                 struct expression *assign_expr)
 107 {
 108         struct fcall_back *tmp;
 109
 110         FOR_EACH_PTR(list, tmp) {
 111                 ((implication_hook *)(tmp->call_back))(fn, call_expr, assign_expr, tmp->info);
 112         } END_FOR_EACH_PTR(tmp);
 113 }
 114
 115 static void match_function_call(struct expression *expr)
 116 {
 117         struct call_back_list *call_backs;
 118
 119         if (expr->fn->type != EXPR_SYMBOL || !expr->fn->symbol)
 120                 return;
 121         call_backs = search_callback(func_hash, (char *)expr->fn->symbol->ident->name);
 122         if (!call_backs)
 123                 return;
 124         call_call_backs(call_backs, REGULAR_CALL, expr->fn->symbol->ident->name,
 125                         expr);
 126 }
 127
 128 static struct call_back_list *get_same_ranged_call_backs(struct call_back_list *list,
 129                                                 struct data_range *drange)
 130 {
 131         struct call_back_list *ret = NULL;
 132         struct fcall_back *tmp;
 133
 134         FOR_EACH_PTR(list, tmp) {
 135                 if (tmp->type != RANGED_CALL)
 136                         continue;
 137                 if (tmp->range->min == drange->min && tmp->range->max == drange->max)
 138                         add_ptr_list(&ret, tmp);
 139         } END_FOR_EACH_PTR(tmp);
 140         return ret;
 141 }
 142
 143 static void assign_ranged_funcs(const char *fn, struct expression *expr,
 144                                  struct call_back_list *call_backs)
 145 {
 146         struct fcall_back *tmp;
 147         struct sm_state *sm;
 148         char *var_name;
 149         struct symbol *sym;
 150         struct smatch_state *extra_state;
 151         struct state_list *tmp_slist;
 152         struct state_list *final_states = NULL;
 153         struct range_list *handled_ranges = NULL;
 154         struct call_back_list *same_range_call_backs = NULL;
 155
 156         var_name = get_variable_from_expr(expr->left, &sym);
 157         if (!var_name || !sym)
 158                 goto free;
 159
 160         FOR_EACH_PTR(call_backs, tmp) {
 161                 if (tmp->type != RANGED_CALL)
 162                         continue;
 163                 if (in_list_exact(handled_ranges, tmp->range))
 164                         continue;
 165                 __push_fake_cur_slist();
 166                 tack_on(&handled_ranges, tmp->range);
 167
 168                 same_range_call_backs = get_same_ranged_call_backs(call_backs, tmp->range);
 169                 call_ranged_call_backs(same_range_call_backs, fn, expr->right, expr);
 170                 __free_ptr_list((struct ptr_list **)&same_range_call_backs);
 171
 172                 extra_state = alloc_extra_state_range(tmp->range->min, tmp->range->max);
 173                 set_extra_mod(var_name, sym, extra_state);
 174
 175                 tmp_slist = __pop_fake_cur_slist();
 176                 merge_slist(&final_states, tmp_slist);
 177                 free_slist(&tmp_slist);
 178         } END_FOR_EACH_PTR(tmp);
 179
 180         FOR_EACH_PTR(final_states, sm) {
 181                 __set_sm(sm);
 182         } END_FOR_EACH_PTR(sm);
 183
 184         free_slist(&final_states);
 185 free:
 186         free_string(var_name);
 187 }
 188
 189 void function_comparison(int comparison, struct expression *expr, long long value, int left)
 190 {
 191         struct call_back_list *call_backs;
 192         struct fcall_back *tmp;
 193         const char *fn;
 194         struct data_range *value_range;
 195         struct state_list *true_states = NULL;
 196         struct state_list *false_states = NULL;
 197         struct state_list *tmp_slist;
 198         struct sm_state *sm;
 199
 200         if (expr->fn->type != EXPR_SYMBOL || !expr->fn->symbol)
 201                 return;
 202         fn = expr->fn->symbol->ident->name;
 203         call_backs = search_callback(func_hash, (char *)expr->fn->symbol->ident->name);
 204         if (!call_backs)
 205                 return;
 206         value_range = alloc_range(value, value);
 207
 208         /* set true states */
 209         __push_fake_cur_slist();
 210         FOR_EACH_PTR(call_backs, tmp) {
 211                 if (tmp->type != RANGED_CALL)
 212                         continue;
 213                 if (!true_comparison_range_lr(comparison, tmp->range, value_range, left))
 214                         continue;
 215                 ((implication_hook *)(tmp->call_back))(fn, expr, NULL, tmp->info);
 216         } END_FOR_EACH_PTR(tmp);
 217         tmp_slist = __pop_fake_cur_slist();
 218         merge_slist(&true_states, tmp_slist);
 219         free_slist(&tmp_slist);
 220
 221         /* set false states */
 222         __push_fake_cur_slist();
 223         FOR_EACH_PTR(call_backs, tmp) {
 224                 if (tmp->type != RANGED_CALL)
 225                         continue;
 226                 if (!false_comparison_range_lr(comparison, tmp->range, value_range, left))
 227                         continue;
 228                 ((implication_hook *)(tmp->call_back))(fn, expr, NULL, tmp->info);
 229         } END_FOR_EACH_PTR(tmp);
 230         tmp_slist = __pop_fake_cur_slist();
 231         merge_slist(&false_states, tmp_slist);
 232         free_slist(&tmp_slist);
 233
 234         FOR_EACH_PTR(true_states, sm) {
 235                 __set_true_false_sm(sm, NULL);
 236         } END_FOR_EACH_PTR(sm);
 237         FOR_EACH_PTR(false_states, sm) {
 238                 __set_true_false_sm(NULL, sm);
 239         } END_FOR_EACH_PTR(sm);
 240
 241         free_slist(&true_states);
 242         free_slist(&false_states);
 243 }
 244
 245 static void match_assign_call(struct expression *expr)
 246 {
 247         struct call_back_list *call_backs;
 248         const char *fn;
 249         struct expression *right;
 250
 251         right = strip_expr(expr->right);
 252         if (right->fn->type != EXPR_SYMBOL || !right->fn->symbol)
 253                 return;
 254         fn = right->fn->symbol->ident->name;
 255         call_backs = search_callback(func_hash, (char *)fn);
 256         if (!call_backs)
 257                 return;
 258         call_call_backs(call_backs, ASSIGN_CALL, fn, expr);
 259         assign_ranged_funcs(fn, expr, call_backs);
 260 }
 261
 262 static void match_macro_assign(struct expression *expr)
 263 {
 264         struct call_back_list *call_backs;
 265         const char *macro;
 266         struct expression *right;
 267
 268         right = strip_expr(expr->right);
 269         macro = get_macro_name(&right->pos);
 270         call_backs = search_callback(func_hash, (char *)macro);
 271         if (!call_backs)
 272                 return;
 273         call_call_backs(call_backs, MACRO_ASSIGN, macro, expr);
 274 }
 275
 276 void create_function_hook_hash(void)
 277 {
 278         func_hash = create_function_hashtable(5000);
 279 }
 280
 281 void register_function_hooks(int id)
 282 {
 283         add_hook(&match_function_call, FUNCTION_CALL_HOOK);
 284         add_hook(&match_assign_call, CALL_ASSIGNMENT_HOOK);
 285         add_hook(&match_macro_assign, MACRO_ASSIGNMENT_HOOK);
 286 }