smatch_var_sym.c

   1 /*
   2  * Copyright (C) 2013 Oracle.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
  16  */
  17
  18 #include "smatch.h"
  19
  20 ALLOCATOR(var_sym, "var_sym structs");
  21
  22 struct var_sym *alloc_var_sym(const char *var, struct symbol *sym)
  23 {
  24         struct var_sym *tmp;
  25
  26         tmp = __alloc_var_sym(0);
  27         tmp->var = alloc_string(var);
  28         tmp->sym = sym;
  29         return tmp;
  30 }
  31
  32 struct var_sym_list *expr_to_vsl(struct expression *expr)
  33 {
  34         struct expression *unop;
  35         struct var_sym_list *ret = NULL;
  36         char *var;
  37         struct symbol *sym;
  38
  39         expr = strip_expr(expr);
  40         if (!expr)
  41                 return NULL;
  42
  43         if ((expr->type == EXPR_PREOP && expr->op == '*') ||
  44             expr->type == EXPR_DEREF) {
  45                 unop = strip_expr(expr->unop);
  46
  47                 if (unop->type == EXPR_SYMBOL)
  48                         goto one_var;
  49                 ret = expr_to_vsl(unop);
  50                 if (ptr_list_size((struct ptr_list *)ret) == 1) {
  51                         ret = NULL;
  52                         goto one_var;
  53                 }
  54                 return ret;
  55         }
  56
  57         if (expr->type == EXPR_BINOP ||
  58             expr->type == EXPR_LOGICAL ||
  59             expr->type == EXPR_COMPARE) {
  60                 struct var_sym_list *left, *right;
  61
  62                 left = expr_to_vsl(expr->left);
  63                 right = expr_to_vsl(expr->right);
  64                 ret = combine_var_sym_lists(left, right);
  65                 free_var_syms_and_list(&left);
  66                 free_var_syms_and_list(&right);
  67                 return ret;
  68         }
  69
  70 one_var:
  71         var = expr_to_var_sym(expr, &sym);
  72         if (!var || !sym) {
  73                 free_string(var);
  74                 return NULL;
  75         }
  76         add_var_sym(&ret, var, sym);
  77         return ret;
  78 }
  79
  80 int cmp_var_sym(const struct var_sym *a, const struct var_sym *b)
  81 {
  82         int ret;
  83
  84         if (a == b)
  85                 return 0;
  86         if (!b)
  87                 return -1;
  88         if (!a)
  89                 return 1;
  90
  91         ret = strcmp(a->var, b->var);
  92         if (ret < 0)
  93                 return -1;
  94         if (ret > 0)
  95                 return 1;
  96
  97         if (!b->sym && a->sym)
  98                 return -1;
  99         if (!a->sym && b->sym)
 100                 return 1;
 101         if (a->sym < b->sym)
 102                 return -1;
 103         if (a->sym > b->sym)
 104                 return 1;
 105
 106         return 0;
 107 }
 108
 109 void add_var_sym(struct var_sym_list **list, const char *var, struct symbol *sym)
 110 {
 111         struct var_sym *tmp, *new;
 112
 113         if (in_var_sym_list(*list, var, sym))
 114                 return;
 115         new = alloc_var_sym(var, sym);
 116
 117         FOR_EACH_PTR(*list, tmp) {
 118                 if (cmp_var_sym(tmp, new) < 0)
 119                         continue;
 120                 else if (cmp_var_sym(tmp, new) == 0) {
 121                         return;
 122                 } else {
 123                         INSERT_CURRENT(new, tmp);
 124                         return;
 125                 }
 126         } END_FOR_EACH_PTR(tmp);
 127         add_ptr_list(list, new);
 128 }
 129
 130 void add_var_sym_expr(struct var_sym_list **list, struct expression *expr)
 131 {
 132         char *var;
 133         struct symbol *sym;
 134
 135         var = expr_to_var_sym(expr, &sym);
 136         if (!var || !sym)
 137                 goto free;
 138         add_var_sym(list, var, sym);
 139 free:
 140         free_string(var);
 141 }
 142
 143 static void free_var_sym(struct var_sym *vs)
 144 {
 145         free_string(vs->var);
 146         __free_var_sym(vs);
 147 }
 148
 149 void del_var_sym(struct var_sym_list **list, const char *var, struct symbol *sym)
 150 {
 151         struct var_sym *tmp;
 152
 153         FOR_EACH_PTR(*list, tmp) {
 154                 if (tmp->sym == sym && strcmp(tmp->var, var) == 0) {
 155                         DELETE_CURRENT_PTR(tmp);
 156                         free_var_sym(tmp);
 157                         return;
 158                 }
 159         } END_FOR_EACH_PTR(tmp);
 160 }
 161
 162 int in_var_sym_list(struct var_sym_list *list, const char *var, struct symbol *sym)
 163 {
 164         struct var_sym *tmp;
 165
 166         FOR_EACH_PTR(list, tmp) {
 167                 if (tmp->sym == sym && strcmp(tmp->var, var) == 0)
 168                         return 1;
 169         } END_FOR_EACH_PTR(tmp);
 170         return 0;
 171 }
 172
 173 struct var_sym_list *clone_var_sym_list(struct var_sym_list *from_vsl)
 174 {
 175         struct var_sym *tmp, *clone_vs;
 176         struct var_sym_list *to_vsl = NULL;
 177
 178         FOR_EACH_PTR(from_vsl, tmp) {
 179                 clone_vs = alloc_var_sym(tmp->var, tmp->sym);
 180                 add_ptr_list(&to_vsl, clone_vs);
 181         } END_FOR_EACH_PTR(tmp);
 182         return to_vsl;
 183 }
 184
 185 void merge_var_sym_list(struct var_sym_list **dest, struct var_sym_list *src)
 186 {
 187         struct var_sym *tmp;
 188
 189         FOR_EACH_PTR(src, tmp) {
 190                 add_var_sym(dest, tmp->var, tmp->sym);
 191         } END_FOR_EACH_PTR(tmp);
 192 }
 193
 194 struct var_sym_list *combine_var_sym_lists(struct var_sym_list *one, struct var_sym_list *two)
 195 {
 196         struct var_sym_list *to_vsl;
 197
 198         to_vsl = clone_var_sym_list(one);
 199         merge_var_sym_list(&to_vsl, two);
 200         return to_vsl;
 201 }
 202
 203 int var_sym_lists_equiv(struct var_sym_list *one, struct var_sym_list *two)
 204 {
 205         struct var_sym *one_tmp, *two_tmp;
 206
 207         if (one == two)
 208                 return 1;
 209
 210         if (ptr_list_size((struct ptr_list *)one) != ptr_list_size((struct ptr_list *)two))
 211                 return 0;
 212
 213         PREPARE_PTR_LIST(one, one_tmp);
 214         PREPARE_PTR_LIST(two, two_tmp);
 215         for (;;) {
 216                 if (!one_tmp && !two_tmp)
 217                         return 1;
 218                 if (one_tmp->sym != two_tmp->sym)
 219                         return 0;
 220                 if (strcmp(one_tmp->var, two_tmp->var) != 0)
 221                         return 0;
 222                 NEXT_PTR_LIST(one_tmp);
 223                 NEXT_PTR_LIST(two_tmp);
 224         }
 225         FINISH_PTR_LIST(two_tmp);
 226         FINISH_PTR_LIST(one_tmp);
 227
 228         return 1;
 229 }
 230
 231 void free_var_sym_list(struct var_sym_list **list)
 232 {
 233         __free_ptr_list((struct ptr_list **)list);
 234 }
 235
 236 void free_var_syms_and_list(struct var_sym_list **list)
 237 {
 238         struct var_sym *tmp;
 239
 240         FOR_EACH_PTR(*list, tmp) {
 241                 free_var_sym(tmp);
 242         } END_FOR_EACH_PTR(tmp);
 243         free_var_sym_list(list);
 244 }
 245