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 */
 247         tmp = pop_slist(&pre_cond_stack);
 248         tmp3 = clone_slist(tmp);
 249         tmp2 = pop_slist(&cond_true_stack);
 250         overwrite_slist(tmp2, &tmp3);
 251         push_slist(&true_stack, tmp3);
 252
 253         tmp2 = pop_slist(&cond_false_stack);
 254         overwrite_slist(tmp2, &tmp);
 255         push_slist(&false_stack, tmp);
 256 }
 257
 258 void __use_true_states()
 259 {
 260         del_slist(&cur_slist);
 261         cur_slist = pop_slist(&true_stack);
 262 }
 263
 264 void __use_false_states()
 265 {
 266         push_slist(&true_stack, clone_slist(cur_slist));
 267         del_slist(&cur_slist);
 268         cur_slist = pop_slist(&false_stack);
 269 }
 270
 271 void __pop_false_states()
 272 {
 273         struct state_list *slist;
 274
 275         slist = pop_slist(&false_stack);
 276         del_slist(&slist);
 277 }
 278
 279 void __merge_false_states()
 280 {
 281         struct state_list *slist;
 282
 283         slist = pop_slist(&false_stack);
 284         merge_slist(slist);
 285         del_slist(&slist);
 286 }
 287
 288 void __merge_true_states()
 289 {
 290         struct state_list *slist;
 291
 292         slist = pop_slist(&true_stack);
 293         merge_slist(slist);
 294         del_slist(&slist);
 295 }
 296
 297 void __pop_true_states()
 298 {
 299         struct state_list *slist;
 300
 301         slist = pop_slist(&true_stack);
 302         del_slist(&slist);
 303 }
 304
 305 void __push_continues()
 306 {
 307         push_slist(&continue_stack, NULL);
 308 }
 309
 310 void __pop_continues()
 311 {
 312         struct state_list *slist;
 313
 314         slist = pop_slist(&continue_stack);
 315         del_slist(&slist);
 316 }
 317
 318 void __process_continues()
 319 {
 320         struct smatch_state *state;
 321
 322         FOR_EACH_PTR(cur_slist, state) {
 323                 merge_state_stack(&continue_stack, state->name, state->owner,
 324                                   state->sym, state->state);
 325         } END_FOR_EACH_PTR(state);
 326 }
 327
 328 void __merge_continues()
 329 {
 330         struct state_list *slist;
 331
 332         slist = pop_slist(&continue_stack);
 333         merge_slist(slist);
 334         del_slist(&slist);
 335 }
 336
 337 void __push_breaks()
 338 {
 339         push_slist(&break_stack, NULL);
 340 }
 341
 342 void __process_breaks()
 343 {
 344         struct smatch_state *state;
 345
 346         FOR_EACH_PTR(cur_slist, state) {
 347                 merge_state_stack(&break_stack, state->name, state->owner,
 348                                   state->sym, state->state);
 349         } END_FOR_EACH_PTR(state);
 350 }
 351
 352 void __merge_breaks()
 353 {
 354         struct state_list *slist;
 355
 356         slist = pop_slist(&break_stack);
 357         merge_slist(slist);
 358         del_slist(&slist);
 359 }
 360
 361 void __use_breaks()
 362 {
 363         del_slist(&cur_slist);
 364         cur_slist = pop_slist(&break_stack);
 365 }
 366
 367 void __pop_breaks()
 368 {
 369         struct state_list *slist;
 370
 371         slist = pop_slist(&break_stack);
 372         del_slist(&slist);
 373 }
 374
 375 void __save_switch_states()
 376 {
 377         push_slist(&switch_stack, clone_slist(cur_slist));
 378 }
 379
 380 void __merge_switches()
 381 {
 382         struct state_list *slist;
 383
 384         slist = pop_slist(&switch_stack);
 385         merge_slist(slist);
 386         push_slist(&switch_stack, slist);
 387 }
 388
 389 void __pop_switches()
 390 {
 391         struct state_list *slist;
 392
 393         slist = pop_slist(&switch_stack);
 394         del_slist(&slist);
 395 }
 396
 397 void __push_default()
 398 {
 399         push_slist(&default_stack, NULL);
 400         set_state_stack(&default_stack, "has_default", 0, NULL, 0);
 401 }
 402
 403 void __set_default()
 404 {
 405         set_state_stack(&default_stack, "has_default", 0, NULL, 1);
 406 }
 407
 408 int __pop_default()
 409 {
 410         struct state_list *slist;
 411         struct smatch_state *state;
 412
 413         int ret = -1;
 414         slist = pop_slist(&default_stack);
 415         FOR_EACH_PTR(slist, state) {
 416                 if (!strcmp(state->name, "has_default"))
 417                         ret = state->state;
 418         } END_FOR_EACH_PTR(state);
 419         del_slist(&slist);
 420         return ret;
 421 }
 422
 423 static struct named_slist *alloc_named_slist(const char *name,
 424                                          struct state_list *slist)
 425 {
 426         struct named_slist *named_slist = __alloc_named_slist(0);
 427
 428         named_slist->name = (char *)name;
 429         named_slist->slist = slist;
 430         return named_slist;
 431 }
 432
 433 void __save_gotos(const char *name)
 434 {
 435         struct state_list *slist;
 436
 437         slist = get_slist_from_slist_stack(name);
 438         if (slist) {
 439                 struct smatch_state *state;
 440                 FOR_EACH_PTR(cur_slist, state) {
 441                         merge_state_slist(&slist, state->name, state->owner,
 442                                           state->sym, state->state);
 443                 } END_FOR_EACH_PTR(state);
 444                 return;
 445         } else {
 446                 struct state_list *slist;
 447                 struct named_slist *named_slist;
 448                 slist = clone_slist(cur_slist);
 449                 named_slist = alloc_named_slist(name, slist);
 450                 add_ptr_list(&goto_stack, named_slist);
 451         }
 452 }
 453
 454 void __merge_gotos(const char *name)
 455 {
 456         struct state_list *slist;
 457
 458         slist = get_slist_from_slist_stack(name);
 459         merge_slist(slist);
 460 }