smatch_states.c

   1 /*
   2  * Copyright (C) 2006 Dan Carpenter.
   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 /*
  19  * You have a lists of states.  kernel = locked, foo = NULL, ...
  20  * When you hit an if {} else {} statement then you swap the list
  21  * of states for a different list of states.  The lists are stored
  22  * on stacks.
  23  *
  24  * At the beginning of this file there are list of the stacks that
  25  * we use.  Each function in this file does something to one of
  26  * of the stacks.
  27  *
  28  * So the smatch_flow.c understands code but it doesn't understand states.
  29  * smatch_flow calls functions in this file.  This file calls functions
  30  * in smatch_slist.c which just has boring generic plumbing for handling
  31  * state lists.  But really it's this file where all the magic happens.
  32  */
  33
  34 #include <stdlib.h>
  35 #include <stdio.h>
  36 #include "smatch.h"
  37 #include "smatch_slist.h"
  38 #include "smatch_extra.h"
  39
  40 struct smatch_state undefined = { .name = "undefined" };
  41 struct smatch_state merged = { .name = "merged" };
  42 struct smatch_state true_state = { .name = "true" };
  43 struct smatch_state false_state = { .name = "false" };
  44
  45 static struct state_list *cur_slist; /* current states */
  46
  47 static struct state_list_stack *true_stack; /* states after a t/f branch */
  48 static struct state_list_stack *false_stack;
  49 static struct state_list_stack *pre_cond_stack; /* states before a t/f branch */
  50
  51 static struct state_list_stack *cond_true_stack; /* states affected by a branch */
  52 static struct state_list_stack *cond_false_stack;
  53
  54 static struct state_list_stack *fake_cur_slist_stack;
  55 static int read_only;
  56
  57 static struct state_list_stack *break_stack;
  58 static struct state_list_stack *switch_stack;
  59 static struct range_list_stack *remaining_cases;
  60 static struct state_list_stack *default_stack;
  61 static struct state_list_stack *continue_stack;
  62
  63 static struct named_stack *goto_stack;
  64
  65 static struct ptr_list *backup;
  66
  67 struct state_list_stack *implied_pools;
  68
  69 int option_debug;
  70
  71 void __print_cur_slist(void)
  72 {
  73         __print_slist(cur_slist);
  74 }
  75
  76 static int in_declarations_bit(void)
  77 {
  78         struct statement *tmp;
  79
  80         FOR_EACH_PTR_REVERSE(big_statement_stack, tmp) {
  81                 if (tmp->type == STMT_DECLARATION)
  82                         return 1;
  83                 return 0;
  84         } END_FOR_EACH_PTR_REVERSE(tmp);
  85         return 0;
  86 }
  87
  88 int unreachable(void)
  89 {
  90         static int reset_warnings = 1;
  91
  92         if (cur_slist) {
  93                 if (!__inline_fn)
  94                         reset_warnings = 1;
  95                 return 0;
  96         }
  97
  98         if (in_declarations_bit())
  99                 return 1;
 100
 101         /* option spammy turns on a noisier version of this */
 102         if (reset_warnings && !option_spammy)
 103                 sm_msg("info: ignoring unreachable code.");
 104         if (!__inline_fn)
 105                 reset_warnings = 0;
 106         return 1;
 107 }
 108
 109 struct sm_state *set_state(int owner, const char *name, struct symbol *sym, struct smatch_state *state)
 110 {
 111         struct sm_state *ret;
 112
 113         if (!name)
 114                 return NULL;
 115
 116         if (read_only)
 117                 sm_msg("Smatch Internal Error: cur_slist is read only.");
 118
 119         if (option_debug || strcmp(check_name(owner), option_debug_check) == 0) {
 120                 struct smatch_state *s;
 121
 122                 s = get_state(owner, name, sym);
 123                 if (!s)
 124                         printf("%d new state. name='%s' [%s] %s\n",
 125                                 get_lineno(), name, check_name(owner), show_state(state));
 126                 else
 127                         printf("%d state change name='%s' [%s] %s => %s\n",
 128                                 get_lineno(), name, check_name(owner), show_state(s),
 129                                 show_state(state));
 130         }
 131
 132         if (owner != -1 && unreachable())
 133                 return NULL;
 134
 135         if (fake_cur_slist_stack)
 136                 set_state_stack(&fake_cur_slist_stack, owner, name, sym, state);
 137
 138         ret =  set_state_slist(&cur_slist, owner, name, sym, state);
 139
 140         if (cond_true_stack) {
 141                 set_state_stack(&cond_true_stack, owner, name, sym, state);
 142                 set_state_stack(&cond_false_stack, owner, name, sym, state);
 143         }
 144         return ret;
 145 }
 146
 147 struct sm_state *set_state_expr(int owner, struct expression *expr, struct smatch_state *state)
 148 {
 149         char *name;
 150         struct symbol *sym;
 151         struct sm_state *ret = NULL;
 152
 153         expr = strip_expr(expr);
 154         name = expr_to_var_sym(expr, &sym);
 155         if (!name || !sym)
 156                 goto free;
 157         ret = set_state(owner, name, sym, state);
 158 free:
 159         free_string(name);
 160         return ret;
 161 }
 162
 163 void __push_fake_cur_slist()
 164 {
 165         push_slist(&fake_cur_slist_stack, NULL);
 166         __save_pre_cond_states();
 167 }
 168
 169 struct state_list *__pop_fake_cur_slist()
 170 {
 171         __use_pre_cond_states();
 172         return pop_slist(&fake_cur_slist_stack);
 173 }
 174
 175 void __free_fake_cur_slist()
 176 {
 177         struct state_list *slist;
 178
 179         __use_pre_cond_states();
 180         slist = pop_slist(&fake_cur_slist_stack);
 181         free_slist(&slist);
 182 }
 183
 184 void __set_fake_cur_slist_fast(struct state_list *slist)
 185 {
 186         push_slist(&pre_cond_stack, cur_slist);
 187         cur_slist = slist;
 188         read_only = 1;
 189 }
 190
 191 void __pop_fake_cur_slist_fast()
 192 {
 193         cur_slist = pop_slist(&pre_cond_stack);
 194         read_only = 0;
 195 }
 196
 197 void __merge_slist_into_cur(struct state_list *slist)
 198 {
 199         struct sm_state *sm;
 200         struct sm_state *orig;
 201         struct sm_state *merged;
 202
 203         FOR_EACH_PTR(slist, sm) {
 204                 orig = get_sm_state(sm->owner, sm->name, sm->sym);
 205                 if (orig)
 206                         merged = merge_sm_states(orig, sm);
 207                 else
 208                         merged = sm;
 209                 __set_sm(merged);
 210         } END_FOR_EACH_PTR(sm);
 211 }
 212
 213 void __set_sm(struct sm_state *sm)
 214 {
 215         if (read_only)
 216                 sm_msg("Smatch Internal Error: cur_slist is read only.");
 217
 218         if (option_debug ||
 219             strcmp(check_name(sm->owner), option_debug_check) == 0) {
 220                 struct smatch_state *s;
 221
 222                 s = get_state(sm->owner, sm->name, sm->sym);
 223                 if (!s)
 224                         printf("%d new state. name='%s' [%s] %s\n",
 225                                 get_lineno(), sm->name, check_name(sm->owner),
 226                                 show_state(sm->state));
 227                 else
 228                         printf("%d state change name='%s' [%s] %s => %s\n",
 229                                 get_lineno(), sm->name, check_name(sm->owner), show_state(s),
 230                                 show_state(sm->state));
 231         }
 232
 233         if (unreachable())
 234                 return;
 235
 236         if (fake_cur_slist_stack)
 237                 overwrite_sm_state_stack(&fake_cur_slist_stack, sm);
 238
 239         overwrite_sm_state(&cur_slist, sm);
 240
 241         if (cond_true_stack) {
 242                 overwrite_sm_state_stack(&cond_true_stack, sm);
 243                 overwrite_sm_state_stack(&cond_false_stack, sm);
 244         }
 245 }
 246
 247 struct smatch_state *get_state(int owner, const char *name, struct symbol *sym)
 248 {
 249         return get_state_slist(cur_slist, owner, name, sym);
 250 }
 251
 252 struct smatch_state *get_state_expr(int owner, struct expression *expr)
 253 {
 254         char *name;
 255         struct symbol *sym;
 256         struct smatch_state *ret = NULL;
 257
 258         expr = strip_expr(expr);
 259         name = expr_to_var_sym(expr, &sym);
 260         if (!name || !sym)
 261                 goto free;
 262         ret = get_state(owner, name, sym);
 263 free:
 264         free_string(name);
 265         return ret;
 266 }
 267
 268 struct state_list *get_possible_states(int owner, const char *name, struct symbol *sym)
 269 {
 270         struct sm_state *sms;
 271
 272         sms = get_sm_state_slist(cur_slist, owner, name, sym);
 273         if (sms)
 274                 return sms->possible;
 275         return NULL;
 276 }
 277
 278 struct state_list *get_possible_states_expr(int owner, struct expression *expr)
 279 {
 280         char *name;
 281         struct symbol *sym;
 282         struct state_list *ret = NULL;
 283
 284         expr = strip_expr(expr);
 285         name = expr_to_var_sym(expr, &sym);
 286         if (!name || !sym)
 287                 goto free;
 288         ret = get_possible_states(owner, name, sym);
 289 free:
 290         free_string(name);
 291         return ret;
 292 }
 293
 294 struct sm_state *get_sm_state(int owner, const char *name, struct symbol *sym)
 295 {
 296         return get_sm_state_slist(cur_slist, owner, name, sym);
 297 }
 298
 299 struct sm_state *get_sm_state_expr(int owner, struct expression *expr)
 300 {
 301         char *name;
 302         struct symbol *sym;
 303         struct sm_state *ret = NULL;
 304
 305         expr = strip_expr(expr);
 306         name = expr_to_var_sym(expr, &sym);
 307         if (!name || !sym)
 308                 goto free;
 309         ret = get_sm_state(owner, name, sym);
 310 free:
 311         free_string(name);
 312         return ret;
 313 }
 314
 315 void delete_state(int owner, const char *name, struct symbol *sym)
 316 {
 317         delete_state_slist(&cur_slist, owner, name, sym);
 318         if (cond_true_stack) {
 319                 delete_state_stack(&pre_cond_stack, owner, name, sym);
 320                 delete_state_stack(&cond_true_stack, owner, name, sym);
 321                 delete_state_stack(&cond_false_stack, owner, name, sym);
 322         }
 323 }
 324
 325 void delete_state_expr(int owner, struct expression *expr)
 326 {
 327         char *name;
 328         struct symbol *sym;
 329
 330         expr = strip_expr(expr);
 331         name = expr_to_var_sym(expr, &sym);
 332         if (!name || !sym)
 333                 goto free;
 334         delete_state(owner, name, sym);
 335 free:
 336         free_string(name);
 337 }
 338
 339 struct state_list *get_all_states_slist(int owner, struct state_list *source)
 340 {
 341         struct state_list *slist = NULL;
 342         struct sm_state *tmp;
 343
 344         FOR_EACH_PTR(source, tmp) {
 345                 if (tmp->owner == owner)
 346                         add_ptr_list(&slist, tmp);
 347         } END_FOR_EACH_PTR(tmp);
 348
 349         return slist;
 350 }
 351
 352 struct state_list *get_all_states(int owner)
 353 {
 354         struct state_list *slist = NULL;
 355         struct sm_state *tmp;
 356
 357         FOR_EACH_PTR(cur_slist, tmp) {
 358                 if (tmp->owner == owner)
 359                         add_ptr_list(&slist, tmp);
 360         } END_FOR_EACH_PTR(tmp);
 361
 362         return slist;
 363 }
 364
 365 int is_reachable(void)
 366 {
 367         if (cur_slist)
 368                 return 1;
 369         return 0;
 370 }
 371
 372 struct state_list *__get_cur_slist(void)
 373 {
 374         return cur_slist;
 375 }
 376
 377 void set_true_false_states(int owner, const char *name, struct symbol *sym,
 378                            struct smatch_state *true_state,
 379                            struct smatch_state *false_state)
 380 {
 381         if (option_debug || strcmp(check_name(owner), option_debug_check) == 0) {
 382                 struct smatch_state *tmp;
 383
 384                 tmp = get_state(owner, name, sym);
 385                 printf("%d set_true_false '%s'.  Was %s.  Now T:%s F:%s\n",
 386                        get_lineno(), name, show_state(tmp),
 387                        show_state(true_state), show_state(false_state));
 388         }
 389
 390         if (unreachable())
 391                 return;
 392
 393         if (!cond_false_stack || !cond_true_stack) {
 394                 printf("Error:  missing true/false stacks\n");
 395                 return;
 396         }
 397
 398         if (true_state) {
 399                 set_state_slist(&cur_slist, owner, name, sym, true_state);
 400                 set_state_stack(&cond_true_stack, owner, name, sym, true_state);
 401         }
 402         if (false_state)
 403                 set_state_stack(&cond_false_stack, owner, name, sym, false_state);
 404 }
 405
 406 void set_true_false_states_expr(int owner, struct expression *expr,
 407                            struct smatch_state *true_state,
 408                            struct smatch_state *false_state)
 409 {
 410         char *name;
 411         struct symbol *sym;
 412
 413         expr = strip_expr(expr);
 414         name = expr_to_var_sym(expr, &sym);
 415         if (!name || !sym)
 416                 goto free;
 417         set_true_false_states(owner, name, sym, true_state, false_state);
 418 free:
 419         free_string(name);
 420 }
 421
 422 void __set_true_false_sm(struct sm_state *true_sm, struct sm_state *false_sm)
 423 {
 424         if (unreachable())
 425                 return;
 426
 427         if (!cond_false_stack || !cond_true_stack) {
 428                 printf("Error:  missing true/false stacks\n");
 429                 return;
 430         }
 431
 432         if (true_sm) {
 433                 overwrite_sm_state(&cur_slist, true_sm);
 434                 overwrite_sm_state_stack(&cond_true_stack, true_sm);
 435         }
 436         if (false_sm)
 437                 overwrite_sm_state_stack(&cond_false_stack, false_sm);
 438 }
 439
 440 void nullify_path(void)
 441 {
 442         free_slist(&cur_slist);
 443 }
 444
 445 void __match_nullify_path_hook(const char *fn, struct expression *expr,
 446                                void *unused)
 447 {
 448         nullify_path();
 449 }
 450
 451 /*
 452  * At the start of every function we mark the path
 453  * as unnull.  That way there is always at least one state
 454  * in the cur_slist until nullify_path is called.  This
 455  * is used in merge_slist() for the first null check.
 456  */
 457 void __unnullify_path(void)
 458 {
 459         set_state(-1, "unnull_path", NULL, &true_state);
 460 }
 461
 462 int __path_is_null(void)
 463 {
 464         if (cur_slist)
 465                 return 0;
 466         return 1;
 467 }
 468
 469 static void check_stack_free(struct state_list_stack **stack)
 470 {
 471         if (*stack) {
 472                 sm_msg("smatch internal error:  stack not empty");
 473                 free_stack_and_slists(stack);
 474         }
 475 }
 476
 477 void save_all_states(void)
 478 {
 479         __add_ptr_list(&backup, cur_slist, 0);
 480
 481         __add_ptr_list(&backup, true_stack, 0);
 482         __add_ptr_list(&backup, false_stack, 0);
 483         __add_ptr_list(&backup, pre_cond_stack, 0);
 484
 485         __add_ptr_list(&backup, cond_true_stack, 0);
 486         __add_ptr_list(&backup, cond_false_stack, 0);
 487
 488         __add_ptr_list(&backup, fake_cur_slist_stack, 0);
 489
 490         __add_ptr_list(&backup, break_stack, 0);
 491         __add_ptr_list(&backup, switch_stack, 0);
 492         __add_ptr_list(&backup, remaining_cases, 0);
 493         __add_ptr_list(&backup, default_stack, 0);
 494         __add_ptr_list(&backup, continue_stack, 0);
 495
 496         __add_ptr_list(&backup, goto_stack, 0);
 497 }
 498
 499 void nullify_all_states(void)
 500 {
 501         cur_slist = NULL;
 502
 503         true_stack = NULL;
 504         false_stack = NULL;
 505         pre_cond_stack = NULL;
 506
 507         cond_true_stack = NULL;
 508         cond_false_stack = NULL;
 509
 510         fake_cur_slist_stack = NULL;
 511
 512         break_stack = NULL;
 513         switch_stack = NULL;
 514         remaining_cases = NULL;
 515         default_stack = NULL;
 516         continue_stack = NULL;
 517
 518         goto_stack = NULL;
 519 }
 520
 521 static void *pop_backup(void)
 522 {
 523         void *ret;
 524
 525         ret = last_ptr_list(backup);
 526         delete_ptr_list_last(&backup);
 527         return ret;
 528 }
 529
 530 void restore_all_states(void)
 531 {
 532         goto_stack = pop_backup();
 533
 534         continue_stack = pop_backup();
 535         default_stack = pop_backup();
 536         remaining_cases = pop_backup();
 537         switch_stack = pop_backup();
 538         break_stack = pop_backup();
 539
 540         fake_cur_slist_stack = pop_backup();
 541
 542         cond_false_stack = pop_backup();
 543         cond_true_stack = pop_backup();
 544
 545         pre_cond_stack = pop_backup();
 546         false_stack = pop_backup();
 547         true_stack = pop_backup();
 548
 549         cur_slist = pop_backup();
 550 }
 551
 552 void clear_all_states(void)
 553 {
 554         struct named_slist *named_slist;
 555
 556         nullify_path();
 557         check_stack_free(&true_stack);
 558         check_stack_free(&false_stack);
 559         check_stack_free(&pre_cond_stack);
 560         check_stack_free(&cond_true_stack);
 561         check_stack_free(&cond_false_stack);
 562         check_stack_free(&break_stack);
 563         check_stack_free(&switch_stack);
 564         check_stack_free(&continue_stack);
 565         free_stack_and_slists(&implied_pools);
 566
 567         FOR_EACH_PTR(goto_stack, named_slist) {
 568                 free_slist(&named_slist->slist);
 569         } END_FOR_EACH_PTR(named_slist);
 570         __free_ptr_list((struct ptr_list **)&goto_stack);
 571         free_every_single_sm_state();
 572 }
 573
 574 void __push_cond_stacks(void)
 575 {
 576         push_slist(&cond_true_stack, NULL);
 577         push_slist(&cond_false_stack, NULL);
 578 }
 579
 580 struct state_list *__copy_cond_true_states(void)
 581 {
 582         struct state_list *ret;
 583
 584         ret = pop_slist(&cond_true_stack);
 585         push_slist(&cond_true_stack, clone_slist(ret));
 586         return ret;
 587 }
 588
 589 struct state_list *__copy_cond_false_states(void)
 590 {
 591         struct state_list *ret;
 592
 593         ret = pop_slist(&cond_false_stack);
 594         push_slist(&cond_false_stack, clone_slist(ret));
 595         return ret;
 596 }
 597
 598 struct state_list *__pop_cond_true_stack(void)
 599 {
 600         return pop_slist(&cond_true_stack);
 601 }
 602
 603 struct state_list *__pop_cond_false_stack(void)
 604 {
 605         return pop_slist(&cond_false_stack);
 606 }
 607
 608 /*
 609  * This combines the pre cond states with either the true or false states.
 610  * For example:
 611  * a = kmalloc() ; if (a !! foo(a)
 612  * In the pre state a is possibly null.  In the true state it is non null.
 613  * In the false state it is null.  Combine the pre and the false to get
 614  * that when we call 'foo', 'a' is null.
 615  */
 616 static void __use_cond_stack(struct state_list_stack **stack)
 617 {
 618         struct state_list *slist;
 619
 620         free_slist(&cur_slist);
 621
 622         cur_slist = pop_slist(&pre_cond_stack);
 623         push_slist(&pre_cond_stack, clone_slist(cur_slist));
 624
 625         slist = pop_slist(stack);
 626         overwrite_slist(slist, &cur_slist);
 627         push_slist(stack, slist);
 628 }
 629
 630 void __use_pre_cond_states(void)
 631 {
 632         free_slist(&cur_slist);
 633         cur_slist = pop_slist(&pre_cond_stack);
 634 }
 635
 636 void __use_cond_true_states(void)
 637 {
 638         __use_cond_stack(&cond_true_stack);
 639 }
 640
 641 void __use_cond_false_states(void)
 642 {
 643         __use_cond_stack(&cond_false_stack);
 644 }
 645
 646 void __negate_cond_stacks(void)
 647 {
 648         struct state_list *old_false, *old_true;
 649
 650         __use_cond_stack(&cond_false_stack);
 651         old_false = pop_slist(&cond_false_stack);
 652         old_true = pop_slist(&cond_true_stack);
 653         push_slist(&cond_false_stack, old_true);
 654         push_slist(&cond_true_stack, old_false);
 655 }
 656
 657 void __and_cond_states(void)
 658 {
 659         and_slist_stack(&cond_true_stack);
 660         or_slist_stack(&pre_cond_stack, cur_slist, &cond_false_stack);
 661 }
 662
 663 void __or_cond_states(void)
 664 {
 665         or_slist_stack(&pre_cond_stack, cur_slist, &cond_true_stack);
 666         and_slist_stack(&cond_false_stack);
 667 }
 668
 669 void __save_pre_cond_states(void)
 670 {
 671         push_slist(&pre_cond_stack, clone_slist(cur_slist));
 672 }
 673
 674 void __discard_pre_cond_states(void)
 675 {
 676         struct state_list *tmp;
 677
 678         tmp = pop_slist(&pre_cond_stack);
 679         free_slist(&tmp);
 680 }
 681
 682 void __use_cond_states(void)
 683 {
 684         struct state_list *pre, *pre_clone, *true_states, *false_states;
 685
 686         pre = pop_slist(&pre_cond_stack);
 687         pre_clone = clone_slist(pre);
 688
 689         true_states = pop_slist(&cond_true_stack);
 690         overwrite_slist(true_states, &pre);
 691         /* we use the true states right away */
 692         free_slist(&cur_slist);
 693         cur_slist = pre;
 694
 695         false_states = pop_slist(&cond_false_stack);
 696         overwrite_slist(false_states, &pre_clone);
 697         push_slist(&false_stack, pre_clone);
 698 }
 699
 700 void __push_true_states(void)
 701 {
 702         push_slist(&true_stack, clone_slist(cur_slist));
 703 }
 704
 705 void __use_false_states(void)
 706 {
 707         free_slist(&cur_slist);
 708         cur_slist = pop_slist(&false_stack);
 709 }
 710
 711 void __discard_false_states(void)
 712 {
 713         struct state_list *slist;
 714
 715         slist = pop_slist(&false_stack);
 716         free_slist(&slist);
 717 }
 718
 719 void __merge_false_states(void)
 720 {
 721         struct state_list *slist;
 722
 723         slist = pop_slist(&false_stack);
 724         merge_slist(&cur_slist, slist);
 725         free_slist(&slist);
 726 }
 727
 728 void __merge_true_states(void)
 729 {
 730         struct state_list *slist;
 731
 732         slist = pop_slist(&true_stack);
 733         merge_slist(&cur_slist, slist);
 734         free_slist(&slist);
 735 }
 736
 737 void __push_continues(void)
 738 {
 739         push_slist(&continue_stack, NULL);
 740 }
 741
 742 void __discard_continues(void)
 743 {
 744         struct state_list *slist;
 745
 746         slist = pop_slist(&continue_stack);
 747         free_slist(&slist);
 748 }
 749
 750 void __process_continues(void)
 751 {
 752         struct state_list *slist;
 753
 754         slist = pop_slist(&continue_stack);
 755         if (!slist)
 756                 slist = clone_slist(cur_slist);
 757         else
 758                 merge_slist(&slist, cur_slist);
 759
 760         push_slist(&continue_stack, slist);
 761 }
 762
 763 static int top_slist_empty(struct state_list_stack **stack)
 764 {
 765         struct state_list *tmp;
 766         int empty = 0;
 767
 768         tmp = pop_slist(stack);
 769         if (!tmp)
 770                 empty = 1;
 771         push_slist(stack, tmp);
 772         return empty;
 773 }
 774
 775 /* a silly loop does this:  while(i--) { return; } */
 776 void __warn_on_silly_pre_loops(void)
 777 {
 778         if (!__path_is_null())
 779                 return;
 780         if (!top_slist_empty(&continue_stack))
 781                 return;
 782         if (!top_slist_empty(&break_stack))
 783                 return;
 784         /* if the path was nullified before the loop, then we already
 785            printed an error earlier */
 786         if (top_slist_empty(&false_stack))
 787                 return;
 788         sm_msg("info: loop could be replaced with if statement.");
 789 }
 790
 791 void __merge_continues(void)
 792 {
 793         struct state_list *slist;
 794
 795         slist = pop_slist(&continue_stack);
 796         merge_slist(&cur_slist, slist);
 797         free_slist(&slist);
 798 }
 799
 800 void __push_breaks(void)
 801 {
 802         push_slist(&break_stack, NULL);
 803 }
 804
 805 void __process_breaks(void)
 806 {
 807         struct state_list *slist;
 808
 809         slist = pop_slist(&break_stack);
 810         if (!slist)
 811                 slist = clone_slist(cur_slist);
 812         else
 813                 merge_slist(&slist, cur_slist);
 814
 815         push_slist(&break_stack, slist);
 816 }
 817
 818 int __has_breaks(void)
 819 {
 820         struct state_list *slist;
 821         int ret;
 822
 823         slist = pop_slist(&break_stack);
 824         ret = !!slist;
 825         push_slist(&break_stack, slist);
 826         return ret;
 827 }
 828
 829 void __merge_breaks(void)
 830 {
 831         struct state_list *slist;
 832
 833         slist = pop_slist(&break_stack);
 834         merge_slist(&cur_slist, slist);
 835         free_slist(&slist);
 836 }
 837
 838 void __use_breaks(void)
 839 {
 840         free_slist(&cur_slist);
 841         cur_slist = pop_slist(&break_stack);
 842 }
 843
 844 void __save_switch_states(struct expression *switch_expr)
 845 {
 846         push_rl(&remaining_cases, __get_implied_values(switch_expr));
 847         push_slist(&switch_stack, clone_slist(cur_slist));
 848 }
 849
 850 void __merge_switches(struct expression *switch_expr, struct expression *case_expr)
 851 {
 852         struct state_list *slist;
 853         struct state_list *implied_slist;
 854
 855         slist = pop_slist(&switch_stack);
 856         implied_slist = __implied_case_slist(switch_expr, case_expr, &remaining_cases, &slist);
 857         merge_slist(&cur_slist, implied_slist);
 858         free_slist(&implied_slist);
 859         push_slist(&switch_stack, slist);
 860 }
 861
 862 void __discard_switches(void)
 863 {
 864         struct state_list *slist;
 865
 866         pop_rl(&remaining_cases);
 867         slist = pop_slist(&switch_stack);
 868         free_slist(&slist);
 869 }
 870
 871 void __push_default(void)
 872 {
 873         push_slist(&default_stack, NULL);
 874 }
 875
 876 void __set_default(void)
 877 {
 878         set_state_stack(&default_stack, 0, "has_default", NULL, &true_state);
 879 }
 880
 881 int __pop_default(void)
 882 {
 883         struct state_list *slist;
 884
 885         slist = pop_slist(&default_stack);
 886         if (slist) {
 887                 free_slist(&slist);
 888                 return 1;
 889         }
 890         return 0;
 891 }
 892
 893 static struct named_slist *alloc_named_slist(const char *name, struct state_list *slist)
 894 {
 895         struct named_slist *named_slist = __alloc_named_slist(0);
 896
 897         named_slist->name = (char *)name;
 898         named_slist->slist = slist;
 899         return named_slist;
 900 }
 901
 902 void __save_gotos(const char *name)
 903 {
 904         struct state_list **slist;
 905         struct state_list *clone;
 906
 907         slist = get_slist_from_named_stack(goto_stack, name);
 908         if (slist) {
 909                 clone = clone_slist(cur_slist);
 910                 merge_slist(slist, clone);
 911                 free_slist(&clone);
 912                 return;
 913         } else {
 914                 struct named_slist *named_slist;
 915
 916                 clone = clone_slist(cur_slist);
 917                 named_slist = alloc_named_slist(name, clone);
 918                 add_ptr_list(&goto_stack, named_slist);
 919         }
 920 }
 921
 922 void __merge_gotos(const char *name)
 923 {
 924         struct state_list **slist;
 925
 926         slist = get_slist_from_named_stack(goto_stack, name);
 927         if (slist)
 928                 merge_slist(&cur_slist, *slist);
 929 }