smatch_states.c

   1 /*
   2  * sparse/smatch_states.c
   3  *
   4  * Copyright (C) 2006 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 struct state_list *cur_slist; /* current states */
  16
  17 static struct state_list_stack *true_stack; /* states after a t/f branch */
  18 static struct state_list_stack *false_stack;
  19 static struct state_list_stack *pre_cond_stack; /* states before a t/f branch */
  20
  21 static struct state_list_stack *cond_true_stack; /* states affected by a branch */
  22 static struct state_list_stack *cond_false_stack;
  23
  24 static struct state_list_stack *break_stack;
  25 static struct state_list_stack *switch_stack;
  26 static struct state_list_stack *default_stack;
  27 static struct state_list_stack *continue_stack;
  28 static struct state_list_stack *false_only_stack;
  29
  30 struct slist_stack *goto_stack;
  31
  32 int debug_states;
  33
  34 void __print_slist(struct state_list *slist)
  35 {
  36         struct smatch_state *state;
  37
  38         printf("dumping slist at %d\n", get_lineno());
  39         FOR_EACH_PTR(slist, state) {
  40                 printf("%s=%d\n", state->name, state->state);
  41         } END_FOR_EACH_PTR(state);
  42         printf("---\n");
  43 }
  44
  45 void __print_cur_slist()
  46 {
  47         __print_slist(cur_slist);
  48 }
  49
  50 void set_state(const char *name, int owner, struct symbol *sym, int state)
  51 {
  52         if (!name)
  53                 return;
  54
  55         if (debug_states) {
  56                 int s;
  57
  58                 s = get_state(name, owner, sym);
  59                 if (s == NOTFOUND)
  60                         printf("%d new state. name='%s' owner=%d: %d\n",
  61                                get_lineno(), name, owner, state);
  62                 else
  63                         printf("%d state change name='%s' owner=%d: %d => %d\n",
  64                                get_lineno(), name, owner, s, state);
  65         }
  66         set_state_slist(&cur_slist, name, owner, sym, state);
  67 }
  68
  69 int get_state(const char *name, int owner, struct symbol *sym)
  70 {
  71         return get_state_slist(cur_slist, name, owner, sym);
  72 }
  73
  74 void delete_state(const char *name, int owner, struct symbol *sym)
  75 {
  76         delete_state_slist(&cur_slist, name, owner, sym);
  77 }
  78
  79 struct state_list *get_current_states(int owner)
  80 {
  81         struct state_list *slist;
  82         struct smatch_state *tmp;
  83
  84         FOR_EACH_PTR(cur_slist, tmp) {
  85                 if (tmp->owner == owner) {
  86                         add_ptr_list(&slist, tmp);
  87                 }
  88         } END_FOR_EACH_PTR(tmp);
  89
  90         return slist;
  91 }
  92
  93 void set_true_false_states(const char *name, int owner, struct symbol *sym,
  94                            int true_state, int false_state)
  95 {
  96
  97         /* fixme.  save history */
  98
  99         SM_DEBUG("%d set_true_false %s.  Was %d.  Now T:%d F:%d\n",
 100                  get_lineno(), name, get_state(name, owner, sym), true_state,
 101                  false_state);
 102
 103         if (!cond_false_stack || !cond_true_stack) {
 104                 printf("Error:  missing true/false stacks\n");
 105                 return;
 106         }
 107
 108         set_state_slist(&cur_slist, name, owner, sym, true_state);
 109         set_state_stack(&cond_true_stack, name, owner, sym, true_state);
 110         set_state_stack(&cond_false_stack, name, owner, sym, false_state);
 111
 112 }
 113
 114 void nullify_path()
 115 {
 116         del_slist(&cur_slist);
 117 }
 118
 119 void clear_all_states()
 120 {
 121         struct named_slist *named_slist;
 122
 123         nullify_path();
 124         del_slist_stack(&true_stack);
 125         del_slist_stack(&false_stack);
 126         del_slist_stack(&false_only_stack);
 127         del_slist_stack(&pre_cond_stack);
 128         del_slist_stack(&cond_true_stack);
 129         del_slist_stack(&cond_false_stack);
 130         del_slist_stack(&break_stack);
 131         del_slist_stack(&switch_stack);
 132         del_slist_stack(&continue_stack);
 133
 134         FOR_EACH_PTR(goto_stack, named_slist) {
 135                 del_slist(&named_slist->slist);
 136         } END_FOR_EACH_PTR(named_slist);
 137         __free_ptr_list((struct ptr_list **)&goto_stack);
 138 }
 139
 140
 141 void __push_cond_stacks()
 142 {
 143         push_slist(&cond_true_stack, NULL);
 144         push_slist(&cond_false_stack, NULL);
 145 }
 146
 147 static void __use_cond_stack(struct state_list_stack **stack)
 148 {
 149         struct state_list *slist;
 150         struct smatch_state *tmp;
 151
 152         del_slist(&cur_slist);
 153         cur_slist = pop_slist(&pre_cond_stack);
 154         push_slist(&pre_cond_stack, clone_slist(cur_slist));
 155
 156         slist = pop_slist(stack);
 157         FOR_EACH_PTR(slist, tmp) {
 158                 set_state(tmp->name, tmp->owner, tmp->sym, tmp->state);
 159         } END_FOR_EACH_PTR(tmp);
 160         push_slist(stack, slist);
 161 }
 162
 163
 164 void __use_cond_true_states()
 165 {
 166         __use_cond_stack(&cond_true_stack);
 167 }
 168
 169 void __use_cond_false_states()
 170 {
 171         __use_cond_stack(&cond_false_stack);
 172 }
 173
 174 void __negate_cond_stacks()
 175 {
 176         struct state_list *old_false, *old_true;
 177
 178         old_false = pop_slist(&cond_false_stack);
 179         old_true = pop_slist(&cond_true_stack);
 180
 181         overwrite_slist(old_false, &cur_slist);
 182
 183         push_slist(&cond_false_stack, old_true);
 184         push_slist(&cond_true_stack, old_false);
 185 }
 186
 187
 188 void __and_cond_states()
 189 {
 190         struct state_list *tmp_slist;
 191
 192         tmp_slist = pop_slist(&cond_true_stack);
 193         and_slist_stack(&cond_true_stack, tmp_slist);
 194         or_slist_stack(&cond_false_stack);
 195 }
 196
 197 void __or_cond_states()
 198 {
 199         struct state_list *tmp_slist;
 200
 201         or_slist_stack(&cond_true_stack);
 202         tmp_slist = pop_slist(&cond_false_stack);
 203         and_slist_stack(&cond_false_stack, tmp_slist);
 204 }
 205
 206
 207 void __save_pre_cond_states()
 208 {
 209         push_slist(&pre_cond_stack, clone_slist(cur_slist));
 210 }
 211
 212 void __pop_pre_cond_states()
 213 {
 214         struct state_list *tmp;
 215
 216         tmp = pop_slist(&pre_cond_stack);
 217         del_slist(&tmp);
 218 }
 219
 220 void __use_false_only_stack()
 221 {
 222         struct state_list *slist;
 223
 224         slist = pop_slist(&false_only_stack);
 225         overwrite_slist(slist, &cur_slist);
 226         del_slist(&slist);
 227 }
 228
 229 void __pop_false_only_stack()
 230 {
 231         struct state_list *slist;
 232
 233         slist = pop_slist(&false_only_stack);
 234         del_slist(&slist);
 235 }
 236
 237 void __use_cond_states()
 238 {
 239         struct state_list *tmp, *tmp2, *tmp3;
 240
 241         tmp = pop_slist(&cond_false_stack);
 242         push_slist(&false_only_stack, clone_slist(tmp));
 243         push_slist(&cond_false_stack, tmp);
 244
 245         /* Everyone calls __use_true_states so setting up
 246            the true stack is enough here.  (We don't need
 247            to set up cur_slist) */
 248         tmp = pop_slist(&pre_cond_stack);
 249         tmp3 = clone_slist(tmp);
 250         tmp2 = pop_slist(&cond_true_stack);
 251         overwrite_slist(tmp2, &tmp3);
 252         push_slist(&true_stack, tmp3);
 253
 254         tmp2 = pop_slist(&cond_false_stack);
 255         overwrite_slist(tmp2, &tmp);
 256         push_slist(&false_stack, tmp);
 257 }
 258
 259 void __use_true_states()
 260 {
 261         del_slist(&cur_slist);
 262         cur_slist = pop_slist(&true_stack);
 263 }
 264
 265 void __use_false_states()
 266 {
 267         push_slist(&true_stack, clone_slist(cur_slist));
 268         del_slist(&cur_slist);
 269         cur_slist = pop_slist(&false_stack);
 270 }
 271
 272 void __pop_false_states()
 273 {
 274         struct state_list *slist;
 275
 276         slist = pop_slist(&false_stack);
 277         del_slist(&slist);
 278 }
 279
 280 void __merge_false_states()
 281 {
 282         struct state_list *slist;
 283
 284         slist = pop_slist(&false_stack);
 285         merge_slist(slist);
 286         del_slist(&slist);
 287 }
 288
 289 void __merge_true_states()
 290 {
 291         struct state_list *slist;
 292
 293         slist = pop_slist(&true_stack);
 294         merge_slist(slist);
 295         del_slist(&slist);
 296 }
 297
 298 void __pop_true_states()
 299 {
 300         struct state_list *slist;
 301
 302         slist = pop_slist(&true_stack);
 303         del_slist(&slist);
 304 }
 305
 306 void __push_continues()
 307 {
 308         push_slist(&continue_stack, NULL);
 309 }
 310
 311 void __pop_continues()
 312 {
 313         struct state_list *slist;
 314
 315         slist = pop_slist(&continue_stack);
 316         del_slist(&slist);
 317 }
 318
 319 void __process_continues()
 320 {
 321         struct smatch_state *state;
 322
 323         FOR_EACH_PTR(cur_slist, state) {
 324                 merge_state_stack(&continue_stack, state->name, state->owner,
 325                                   state->sym, state->state);
 326         } END_FOR_EACH_PTR(state);
 327 }
 328
 329 void __merge_continues()
 330 {
 331         struct state_list *slist;
 332
 333         slist = pop_slist(&continue_stack);
 334         merge_slist(slist);
 335         del_slist(&slist);
 336 }
 337
 338 void __push_breaks()
 339 {
 340         push_slist(&break_stack, NULL);
 341 }
 342
 343 void __process_breaks()
 344 {
 345         struct smatch_state *state;
 346
 347         FOR_EACH_PTR(cur_slist, state) {
 348                 merge_state_stack(&break_stack, state->name, state->owner,
 349                                   state->sym, state->state);
 350         } END_FOR_EACH_PTR(state);
 351 }
 352
 353 void __merge_breaks()
 354 {
 355         struct state_list *slist;
 356
 357         slist = pop_slist(&break_stack);
 358         merge_slist(slist);
 359         del_slist(&slist);
 360 }
 361
 362 void __use_breaks()
 363 {
 364         del_slist(&cur_slist);
 365         cur_slist = pop_slist(&break_stack);
 366 }
 367
 368 void __pop_breaks()
 369 {
 370         struct state_list *slist;
 371
 372         slist = pop_slist(&break_stack);
 373         del_slist(&slist);
 374 }
 375
 376 void __save_switch_states()
 377 {
 378         push_slist(&switch_stack, clone_slist(cur_slist));
 379 }
 380
 381 void __merge_switches()
 382 {
 383         struct state_list *slist;
 384
 385         slist = pop_slist(&switch_stack);
 386         merge_slist(slist);
 387         push_slist(&switch_stack, slist);
 388 }
 389
 390 void __pop_switches()
 391 {
 392         struct state_list *slist;
 393
 394         slist = pop_slist(&switch_stack);
 395         del_slist(&slist);
 396 }
 397
 398 void __push_default()
 399 {
 400         push_slist(&default_stack, NULL);
 401         set_state_stack(&default_stack, "has_default", 0, NULL, 0);
 402 }
 403
 404 void __set_default()
 405 {
 406         set_state_stack(&default_stack, "has_default", 0, NULL, 1);
 407 }
 408
 409 int __pop_default()
 410 {
 411         struct state_list *slist;
 412         struct smatch_state *state;
 413
 414         int ret = -1;
 415         slist = pop_slist(&default_stack);
 416         FOR_EACH_PTR(slist, state) {
 417                 if (!strcmp(state->name, "has_default"))
 418                         ret = state->state;
 419         } END_FOR_EACH_PTR(state);
 420         del_slist(&slist);
 421         return ret;
 422 }
 423
 424 static struct named_slist *alloc_named_slist(const char *name,
 425                                          struct state_list *slist)
 426 {
 427         struct named_slist *named_slist = __alloc_named_slist(0);
 428
 429         named_slist->name = (char *)name;
 430         named_slist->slist = slist;
 431         return named_slist;
 432 }
 433
 434 void __save_gotos(const char *name)
 435 {
 436         struct state_list *slist;
 437
 438         slist = get_slist_from_slist_stack(goto_stack, name);
 439         if (slist) {
 440                 struct smatch_state *state;
 441
 442                 FOR_EACH_PTR(cur_slist, state) {
 443                         merge_state_slist(&slist, state->name, state->owner,
 444                                           state->sym, state->state);
 445                 } END_FOR_EACH_PTR(state);
 446                 return;
 447         } else {
 448                 struct state_list *slist;
 449                 struct named_slist *named_slist;
 450
 451                 slist = clone_slist(cur_slist);
 452                 named_slist = alloc_named_slist(name, slist);
 453                 add_ptr_list(&goto_stack, named_slist);
 454         }
 455 }
 456
 457 void __merge_gotos(const char *name)
 458 {
 459         struct state_list *slist;
 460
 461         slist = get_slist_from_slist_stack(goto_stack, name);
 462         merge_slist(slist);
 463 }