smatch_slist.c

   1 /*
   2  * sparse/smatch_slist.c
   3  *
   4  * Copyright (C) 2008 Dan Carpenter.
   5  *
   6  *  Licensed under the Open Software License version 1.1
   7  *
   8  */
   9
  10 #include <stdlib.h>
  11 #include <stdio.h>
  12 #include "smatch.h"
  13 #include "smatch_slist.h"
  14
  15 ALLOCATOR(smatch_state, "smatch state");
  16 ALLOCATOR(named_slist, "named slist");
  17
  18 void add_history(struct smatch_state *state)
  19 {
  20         struct state_history *tmp;
  21
  22         if (!state)
  23                 return;
  24         tmp = malloc(sizeof(*tmp));
  25         tmp->loc = get_lineno();
  26         add_ptr_list(&state->line_history, tmp);
  27 }
  28
  29 struct smatch_state *alloc_state(const char *name, int owner,
  30                                  struct symbol *sym, int state)
  31 {
  32         struct smatch_state *sm_state = __alloc_smatch_state(0);
  33
  34         sm_state->name = (char *)name;
  35         sm_state->owner = owner;
  36         sm_state->sym = sym;
  37         sm_state->state = state;
  38         sm_state->line_history = NULL;
  39         sm_state->path_history = NULL;
  40         add_history(sm_state);
  41         return sm_state;
  42 }
  43
  44 struct smatch_state *clone_state(struct smatch_state *s)
  45 {
  46         return alloc_state(s->name, s->owner, s->sym, s->state);
  47 }
  48
  49 struct state_list *clone_slist(struct state_list *from_slist)
  50 {
  51         struct smatch_state *state;
  52         struct smatch_state *tmp;
  53         struct state_list *to_slist = NULL;
  54
  55         FOR_EACH_PTR(from_slist, state) {
  56                 tmp = clone_state(state);
  57                 add_ptr_list(&to_slist, tmp);
  58         } END_FOR_EACH_PTR(state);
  59         return to_slist;
  60 }
  61
  62 int merge_states(const char *name, int owner, struct symbol *sym,
  63                  int state1, int state2)
  64 {
  65         int ret;
  66
  67         if (state1 == state2)
  68                 ret = state1;
  69         else if (__has_merge_function(owner))
  70                 ret = __client_merge_function(owner, name, sym,
  71                                               (state1 < state2?state1:state2),
  72                                               (state1 > state2?state1:state2));
  73         else
  74                 ret = UNDEFINED;
  75
  76         SM_DEBUG("%d merge name='%s' owner=%d: %d + %d => %d\n",
  77                  get_lineno(), name, owner, state1, state2, ret);
  78
  79         return ret;
  80 }
  81
  82 void merge_state_slist(struct state_list **slist, const char *name, int owner,
  83                        struct symbol *sym, int state)
  84 {
  85         struct smatch_state *tmp;
  86         int s;
  87
  88         FOR_EACH_PTR(*slist, tmp) {
  89                 if (tmp->owner == owner && tmp->sym == sym
  90                     && !strcmp(tmp->name, name)){
  91                         s = merge_states(name, owner, sym, tmp->state, state);
  92                         if (tmp->state != s) {
  93                                 add_history(tmp);
  94                         }
  95                         tmp->state = s;
  96                         return;
  97                 }
  98         } END_FOR_EACH_PTR(tmp);
  99         tmp = alloc_state(name, owner, sym, state);
 100         add_state_slist(slist, tmp);
 101 }
 102
 103 int get_state_slist(struct state_list *slist, const char *name, int owner,
 104                     struct symbol *sym)
 105 {
 106         struct smatch_state *state;
 107
 108         if (!name)
 109                 return NOTFOUND;
 110
 111         FOR_EACH_PTR(slist, state) {
 112                 if (state->owner == owner && state->sym == sym
 113                     && !strcmp(state->name, name))
 114                         return state->state;
 115         } END_FOR_EACH_PTR(state);
 116         return NOTFOUND;
 117 }
 118
 119 void add_state_slist(struct state_list **slist, struct smatch_state *state)
 120 {
 121         add_ptr_list(slist, state);
 122 }
 123
 124 void set_state_slist(struct state_list **slist, const char *name, int owner,
 125                      struct symbol *sym, int state)
 126 {
 127         struct smatch_state *tmp;
 128
 129         FOR_EACH_PTR(*slist, tmp) {
 130                 if (tmp->owner == owner && tmp->sym == sym
 131                     && !strcmp(tmp->name, name)){
 132                         tmp->state = state;
 133                         return;
 134                 }
 135         } END_FOR_EACH_PTR(tmp);
 136         tmp = alloc_state(name, owner, sym, state);
 137         add_state_slist(slist, tmp);
 138 }
 139
 140 void delete_state_slist(struct state_list **slist, const char *name, int owner,
 141                         struct symbol *sym)
 142 {
 143         struct smatch_state *state;
 144
 145         FOR_EACH_PTR(*slist, state) {
 146                 if (state->owner == owner && state->sym == sym
 147                     && !strcmp(state->name, name)){
 148                         delete_ptr_list_entry((struct ptr_list **)slist,
 149                                               state, 1);
 150                         __free_smatch_state(state);
 151                         return;
 152                 }
 153         } END_FOR_EACH_PTR(state);
 154 }
 155
 156
 157 void push_slist(struct state_list_stack **list_stack, struct state_list *slist)
 158 {
 159         add_ptr_list(list_stack, slist);
 160 }
 161
 162 struct state_list *pop_slist(struct state_list_stack **list_stack)
 163 {
 164         struct state_list *slist;
 165
 166         slist = last_ptr_list((struct ptr_list *)*list_stack);
 167         delete_ptr_list_entry((struct ptr_list **)list_stack, slist, 1);
 168         return slist;
 169 }
 170
 171 void del_slist(struct state_list **slist)
 172 {
 173         __free_ptr_list((struct ptr_list **)slist);
 174 }
 175
 176 void del_slist_stack(struct state_list_stack **slist_stack)
 177 {
 178         struct state_list *slist;
 179
 180         FOR_EACH_PTR(*slist_stack, slist) {
 181                 __free_ptr_list((struct ptr_list **)&slist);
 182         } END_FOR_EACH_PTR(slist);
 183         __free_ptr_list((struct ptr_list **)slist_stack);
 184 }
 185
 186 /*
 187  * set_state_stack() sets the state for the top slist on the stack.
 188  */
 189 void set_state_stack(struct state_list_stack **stack, const char *name,
 190                      int owner, struct symbol *sym, int state)
 191 {
 192         struct state_list *slist;
 193
 194         slist = pop_slist(stack);
 195         set_state_slist(&slist, name, owner, sym, state);
 196         push_slist(stack, slist);
 197 }
 198
 199 /*
 200  * get_state_stack() gets the state for the top slist on the stack.
 201  */
 202 int get_state_stack(struct state_list_stack *stack, const char *name,
 203                     int owner, struct symbol *sym)
 204 {
 205         struct state_list *slist;
 206         int ret;
 207
 208         slist = pop_slist(&stack);
 209         ret = get_state_slist(slist, name, owner, sym);
 210         push_slist(&stack, slist);
 211         return ret;
 212 }
 213
 214 void merge_state_stack(struct state_list_stack **stack, const char *name,
 215                        int owner, struct symbol *sym, int state)
 216 {
 217         struct state_list *slist;
 218
 219         slist = pop_slist(stack);
 220         merge_state_slist(&slist, name, owner, sym, state);
 221         push_slist(stack, slist);
 222 }
 223
 224 void merge_slist(struct state_list *slist)
 225 {
 226         struct smatch_state *state;
 227
 228         if (get_state_slist(slist, "null_path", 0, NULL) == 1) {
 229                 SM_DEBUG("%d ignoring merge of null path\n", get_lineno());
 230                 return;
 231         }
 232
 233         FOR_EACH_PTR(slist, state) {
 234                 merge_state_slist(&cur_slist, state->name, state->owner,
 235                                   state->sym, state->state);
 236         } END_FOR_EACH_PTR(state);
 237
 238         FOR_EACH_PTR(cur_slist, state) {
 239                 if (get_state_slist(slist, state->name, state->owner,
 240                                     state->sym) == NOTFOUND) {
 241                         merge_state_slist(&cur_slist, state->name, state->owner,
 242                                           state->sym, NOTFOUND);
 243                 }
 244         } END_FOR_EACH_PTR(state);
 245 }
 246
 247 /*
 248  * and_slist_stack() ands an slist with the top slist in an slist stack.
 249  */
 250
 251 void and_slist_stack(struct state_list_stack **slist_stack,
 252                      struct state_list *tmp_slist)
 253 {
 254         struct smatch_state *tmp;
 255         int tmp_state;
 256
 257         FOR_EACH_PTR(tmp_slist, tmp) {
 258                 tmp_state = get_state_stack(*slist_stack, tmp->name,
 259                                             tmp->owner, tmp->sym);
 260                 if (tmp_state >= 0 && tmp_state != tmp->state) {
 261                         smatch_msg("wierdness merging 'and' conditions states '%s': %d & %d.\n",
 262                                    tmp->name, tmp_state, tmp->state);
 263                         tmp->state = merge_states(tmp->name, tmp->owner,
 264                                                   tmp->sym, tmp->state,
 265                                                   tmp_state);
 266                 }
 267
 268                 set_state_stack(slist_stack, tmp->name, tmp->owner, tmp->sym,
 269                                 tmp->state);
 270
 271         } END_FOR_EACH_PTR(tmp);
 272 //      del_slist(&tmp_slist);
 273 }
 274
 275 void or_slist_stack(struct state_list_stack **slist_stack)
 276 {
 277         struct state_list *one;
 278         struct state_list *two;
 279         struct state_list *res = NULL;
 280         struct smatch_state *tmp;
 281         int s;
 282
 283         one = pop_slist(slist_stack);
 284         two = pop_slist(slist_stack);
 285
 286         FOR_EACH_PTR(one, tmp) {
 287                 s = get_state_slist(two, tmp->name, tmp->owner, tmp->sym);
 288                 s = merge_states(tmp->name, tmp->owner, tmp->sym,
 289                                  tmp->state, s);
 290                 set_state_slist(&res, tmp->name, tmp->owner, tmp->sym, s);
 291         } END_FOR_EACH_PTR(tmp);
 292
 293         push_slist(slist_stack, res);
 294
 295         del_slist(&one);
 296         del_slist(&two);
 297 }
 298
 299 struct state_list *get_slist_from_slist_stack(struct slist_stack *stack,
 300                                               const char *name)
 301 {
 302         struct named_slist *tmp;
 303
 304         FOR_EACH_PTR(stack, tmp) {
 305                 if (!strcmp(tmp->name, name))
 306                         return tmp->slist;
 307         } END_FOR_EACH_PTR(tmp);
 308         return NULL;
 309 }
 310
 311 void overwrite_slist(struct state_list *from, struct state_list **to)
 312 {
 313         struct smatch_state *tmp;
 314
 315         FOR_EACH_PTR(from, tmp) {
 316                 set_state_slist(to, tmp->name, tmp->owner, tmp->sym, tmp->state);
 317         } END_FOR_EACH_PTR(tmp);
 318 }
 319