smatch_local_values.c

   1 /*
   2  * smatch/local_values.c
   3  *
   4  * Copyright (C) 2013 Oracle.
   5  *
   6  * Licensed under the Open Software License version 1.1
   7  *
   8  */
   9
  10 #include "scope.h"
  11 #include "smatch.h"
  12 #include "smatch_slist.h"
  13 #include "smatch_extra.h"
  14
  15 static int my_id;
  16
  17 /*
  18  * I'm going to store the states of local data at the end of each function.
  19  * Then at the end of the file, I'll combine the possible range lists for
  20  * each state and store the value in the on-disk database.
  21  *
  22  * One issue is that when I read the data back from the in-memory database at
  23  * the end of the file, then I don't have access to type information.  I'll just
  24  * cast everything to "long long" for now, I guess.  We'll see how that works.
  25  */
  26
  27 static char *db_vals;
  28 static int get_vals(void *unused, int argc, char **argv, char **azColName)
  29 {
  30         db_vals = alloc_string(argv[0]);
  31         return 0;
  32 }
  33
  34 int get_local_rl(struct expression *expr, struct range_list **rl)
  35 {
  36         char *name;
  37         struct range_list *tmp;
  38
  39         if (!is_static(expr))
  40                 return 0;
  41         name = expr_to_var(expr);
  42         if (!name)
  43                 return 0;
  44
  45         db_vals = NULL;
  46         run_sql(get_vals,
  47                 "select value from local_values where file = '%s' and variable = '%s'",
  48                 get_filename(), name);
  49         free_string(name);
  50         if (!db_vals)
  51                 return 0;
  52         str_to_rl(&llong_ctype, db_vals, &tmp);
  53         *rl = cast_rl(get_type(expr), tmp);
  54         free_string(db_vals);
  55
  56         return 1;
  57 }
  58
  59 int get_local_max_helper(struct expression *expr, sval_t *sval)
  60 {
  61         struct range_list *rl;
  62
  63         if (!get_local_rl(expr, &rl))
  64                 return 0;
  65         *sval = rl_max(rl);
  66         return 1;
  67 }
  68
  69 int get_local_min_helper(struct expression *expr, sval_t *sval)
  70 {
  71         struct range_list *rl;
  72
  73         if (!get_local_rl(expr, &rl))
  74                 return 0;
  75         *sval = rl_min(rl);
  76         return 1;
  77 }
  78
  79 static struct smatch_state *unmatched_state(struct sm_state *sm)
  80 {
  81         return alloc_estate_empty();
  82 }
  83
  84 static void extra_mod_hook(const char *name, struct symbol *sym, struct smatch_state *state)
  85 {
  86         struct smatch_state *old;
  87         struct smatch_state *new;
  88
  89         if (!sym || !(sym->ctype.modifiers & MOD_STATIC))
  90                 return;
  91         old = get_state(my_id, name, sym);
  92         if (old)
  93                 new = merge_estates(old, state);
  94         else
  95                 new = state;
  96         set_state(my_id, name, sym, new);
  97 }
  98
  99 static void process_states(struct state_list *slist)
 100 {
 101         struct sm_state *sm;
 102         struct smatch_state *extra;
 103         struct range_list *rl;
 104
 105         FOR_EACH_PTR(slist, sm) {
 106                 if (sm->owner != my_id)
 107                         continue;
 108                 extra = get_state_slist(slist, SMATCH_EXTRA, sm->name, sm->sym);
 109                 if (extra && estate_rl(extra))
 110                         rl = rl_intersection(estate_rl(sm->state), estate_rl(extra));
 111                 else
 112                         rl = estate_rl(sm->state);
 113                 rl = cast_rl(&llong_ctype, rl);
 114                 mem_sql(NULL,
 115                         "insert into local_values values ('%s', '%s', '%s', %lu);",
 116                         get_filename(), sm->name, show_rl(rl),
 117                         (unsigned long)sm->sym);
 118         } END_FOR_EACH_PTR(sm);
 119 }
 120
 121 static int get_initial_value_sym(struct symbol *sym, char *name, sval_t *sval)
 122 {
 123         struct expression *expr_symbol, *deref, *tmp;
 124         char *member_name;
 125
 126         if (!sym)
 127                 return 0;
 128
 129         if (!sym->initializer) {
 130                 *sval = sval_type_val(&llong_ctype, 0);
 131                 return 1;
 132         }
 133         if (sym->initializer->type != EXPR_INITIALIZER)
 134                 return get_value(sym->initializer, sval);
 135
 136         expr_symbol = symbol_expression(sym);
 137         FOR_EACH_PTR(sym->initializer->expr_list, tmp) {
 138                 if (tmp->type != EXPR_IDENTIFIER) /* how to handle arrays?? */
 139                         continue;
 140                 deref = member_expression(expr_symbol, '.', tmp->expr_ident);
 141                 member_name = expr_to_var(deref);
 142                 if (!member_name)
 143                         continue;
 144                 if (strcmp(name, member_name) == 0) {
 145                         free_string(member_name);
 146                         return get_value(tmp->ident_expression, sval);
 147                 }
 148                 free_string(member_name);
 149         } END_FOR_EACH_PTR(tmp);
 150
 151         return 0;
 152 }
 153
 154 static char *cur_name;
 155 static struct symbol *cur_symbol;
 156 static struct range_list *cur_rl;
 157 static void add_current_local(void)
 158 {
 159         sval_t initial;
 160
 161         if (!get_initial_value_sym(cur_symbol, cur_name, &initial)) {
 162                 free_string(cur_name);
 163                 cur_name = NULL;
 164                 cur_rl = NULL;
 165                 return;
 166         }
 167         add_range(&cur_rl, initial, initial);
 168         if (!is_whole_rl(cur_rl))
 169                 sql_insert_local_values(cur_name, show_rl(cur_rl));
 170         free_string(cur_name);
 171         cur_name = NULL;
 172         cur_rl = NULL;
 173 }
 174
 175 static int save_final_values(void *unused, int argc, char **argv, char **azColName)
 176 {
 177         char *name = argv[0];
 178         char *sym_str = argv[1];
 179         char *value = argv[2];
 180         struct range_list *rl;
 181
 182         if (!cur_name) {
 183                 cur_name = alloc_string(name);
 184                 cur_symbol = (struct symbol *)strtoul(sym_str, NULL, 10);
 185         } else if (strcmp(cur_name, name) != 0) {
 186                 add_current_local();
 187                 cur_name = alloc_string(name);
 188                 cur_symbol = (struct symbol *)strtoul(sym_str, NULL, 10);
 189                 cur_rl = NULL;
 190         }
 191
 192         str_to_rl(&llong_ctype, value, &rl);
 193         cur_rl = rl_union(cur_rl, rl);
 194
 195         return 0;
 196 }
 197
 198 static void match_end_file(struct symbol_list *sym_list)
 199 {
 200         mem_sql(save_final_values,
 201                 "select distinct variable, symbol, value from local_values order by variable;");
 202         if (cur_name)
 203                 add_current_local();
 204 }
 205
 206 void register_local_values(int id)
 207 {
 208         my_id = id;
 209
 210         if (!option_info)
 211                 return;
 212
 213         add_extra_mod_hook(&extra_mod_hook);
 214         add_unmatched_state_hook(my_id, &unmatched_state);
 215         add_merge_hook(my_id, &merge_estates);
 216         all_return_states_hook(&process_states);
 217         add_hook(match_end_file, END_FILE_HOOK);
 218         mem_sql(NULL, "alter table local_values add column symbol integer;");
 219 }