2 * Copyright (C) 2006 Dan Carpenter.
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.
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.
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
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
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
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.
37 #include "smatch_slist.h"
38 #include "smatch_extra.h"
40 struct smatch_state undefined
= { .name
= "undefined" };
41 struct smatch_state ghost
= { .name
= "ghost" };
42 struct smatch_state merged
= { .name
= "merged" };
43 struct smatch_state true_state
= { .name
= "true" };
44 struct smatch_state false_state
= { .name
= "false" };
46 static struct stree
*cur_stree
; /* current states */
48 static struct stree_stack
*true_stack
; /* states after a t/f branch */
49 static struct stree_stack
*false_stack
;
50 static struct stree_stack
*pre_cond_stack
; /* states before a t/f branch */
52 static struct stree_stack
*cond_true_stack
; /* states affected by a branch */
53 static struct stree_stack
*cond_false_stack
;
55 static struct stree_stack
*fake_cur_stree_stack
;
58 static struct stree_stack
*break_stack
;
59 static struct stree_stack
*fake_break_stack
;
60 static struct stree_stack
*switch_stack
;
61 static struct range_list_stack
*remaining_cases
;
62 static struct stree_stack
*default_stack
;
63 static struct stree_stack
*continue_stack
;
65 static struct named_stree_stack
*goto_stack
;
67 static struct ptr_list
*backup
;
71 void __print_cur_stree(void)
73 __print_stree(cur_stree
);
83 struct sm_state
*set_state(int owner
, const char *name
, struct symbol
*sym
, struct smatch_state
*state
)
91 sm_perror("cur_stree is read only.");
93 if (option_debug
|| strcmp(check_name(owner
), option_debug_check
) == 0) {
94 struct smatch_state
*s
;
96 s
= get_state(owner
, name
, sym
);
98 sm_msg("%s new [%s] '%s' %s", __func__
,
99 check_name(owner
), name
, show_state(state
));
101 sm_msg("%s change [%s] '%s' %s => %s",
102 __func__
, check_name(owner
), name
, show_state(s
),
106 if (owner
!= -1 && unreachable())
109 if (fake_cur_stree_stack
)
110 set_state_stree_stack(&fake_cur_stree_stack
, owner
, name
, sym
, state
);
112 ret
= set_state_stree(&cur_stree
, owner
, name
, sym
, state
);
117 struct sm_state
*set_state_expr(int owner
, struct expression
*expr
, struct smatch_state
*state
)
121 struct sm_state
*ret
= NULL
;
123 expr
= strip_expr(expr
);
124 name
= expr_to_var_sym(expr
, &sym
);
127 ret
= set_state(owner
, name
, sym
, state
);
133 void __swap_cur_stree(struct stree
*stree
)
135 free_stree(&cur_stree
);
139 void __push_fake_cur_stree(void)
141 push_stree(&fake_cur_stree_stack
, NULL
);
142 __save_pre_cond_states();
145 struct stree
*__pop_fake_cur_stree(void)
147 if (!fake_cur_stree_stack
)
148 sm_perror("popping too many fake cur strees.");
149 __use_pre_cond_states();
150 return pop_stree(&fake_cur_stree_stack
);
153 void __free_fake_cur_stree(void)
157 stree
= __pop_fake_cur_stree();
161 void __set_fake_cur_stree_fast(struct stree
*stree
)
163 push_stree(&pre_cond_stack
, cur_stree
);
168 void __pop_fake_cur_stree_fast(void)
170 cur_stree
= pop_stree(&pre_cond_stack
);
174 void __merge_stree_into_cur(struct stree
*stree
)
177 struct sm_state
*orig
;
178 struct sm_state
*merged
;
180 FOR_EACH_SM(stree
, sm
) {
181 orig
= get_sm_state(sm
->owner
, sm
->name
, sm
->sym
);
183 merged
= merge_sm_states(orig
, sm
);
187 } END_FOR_EACH_SM(sm
);
190 void __set_sm(struct sm_state
*sm
)
193 sm_perror("cur_stree is read only.");
196 strcmp(check_name(sm
->owner
), option_debug_check
) == 0) {
197 struct smatch_state
*s
;
199 s
= get_state(sm
->owner
, sm
->name
, sm
->sym
);
201 sm_msg("%s new %s", __func__
, show_sm(sm
));
203 sm_msg("%s change %s (was %s)", __func__
, show_sm(sm
),
210 if (fake_cur_stree_stack
)
211 overwrite_sm_state_stree_stack(&fake_cur_stree_stack
, sm
);
213 overwrite_sm_state_stree(&cur_stree
, sm
);
216 void __set_sm_cur_stree(struct sm_state
*sm
)
219 sm_perror("cur_stree is read only.");
222 strcmp(check_name(sm
->owner
), option_debug_check
) == 0) {
223 struct smatch_state
*s
;
225 s
= get_state(sm
->owner
, sm
->name
, sm
->sym
);
227 sm_msg("%s new %s", __func__
, show_sm(sm
));
229 sm_msg("%s change %s (was %s)",
230 __func__
, show_sm(sm
), show_state(s
));
236 overwrite_sm_state_stree(&cur_stree
, sm
);
239 void __set_sm_fake_stree(struct sm_state
*sm
)
242 sm_perror("cur_stree is read only.");
245 strcmp(check_name(sm
->owner
), option_debug_check
) == 0) {
246 struct smatch_state
*s
;
248 s
= get_state(sm
->owner
, sm
->name
, sm
->sym
);
250 sm_msg("%s new %s", __func__
, show_sm(sm
));
252 sm_msg("%s change %s (was %s)",
253 __func__
, show_sm(sm
), show_state(s
));
259 overwrite_sm_state_stree_stack(&fake_cur_stree_stack
, sm
);
263 typedef void (get_state_hook
)(int owner
, const char *name
, struct symbol
*sym
);
264 DECLARE_PTR_LIST(fn_list
, get_state_hook
*);
265 static struct fn_list
*get_state_hooks
;
267 void add_get_state_hook(get_state_hook
*fn
)
269 get_state_hook
**p
= malloc(sizeof(get_state_hook
*));
271 add_ptr_list(&get_state_hooks
, p
);
274 static void call_get_state_hooks(int owner
, const char *name
, struct symbol
*sym
)
276 static int recursion
;
283 FOR_EACH_PTR(get_state_hooks
, fn
) {
284 (*fn
)(owner
, name
, sym
);
285 } END_FOR_EACH_PTR(fn
);
290 struct smatch_state
*__get_state(int owner
, const char *name
, struct symbol
*sym
)
292 return get_state_stree(cur_stree
, owner
, name
, sym
);
295 struct smatch_state
*get_state(int owner
, const char *name
, struct symbol
*sym
)
297 call_get_state_hooks(owner
, name
, sym
);
299 return __get_state(owner
, name
, sym
);
302 struct smatch_state
*get_state_expr(int owner
, struct expression
*expr
)
306 struct smatch_state
*ret
= NULL
;
308 expr
= strip_expr(expr
);
309 name
= expr_to_var_sym(expr
, &sym
);
312 ret
= get_state(owner
, name
, sym
);
318 struct state_list
*get_possible_states(int owner
, const char *name
, struct symbol
*sym
)
320 struct sm_state
*sms
;
322 sms
= get_sm_state_stree(cur_stree
, owner
, name
, sym
);
324 return sms
->possible
;
328 struct state_list
*get_possible_states_expr(int owner
, struct expression
*expr
)
332 struct state_list
*ret
= NULL
;
334 expr
= strip_expr(expr
);
335 name
= expr_to_var_sym(expr
, &sym
);
338 ret
= get_possible_states(owner
, name
, sym
);
344 struct sm_state
*get_sm_state(int owner
, const char *name
, struct symbol
*sym
)
346 return get_sm_state_stree(cur_stree
, owner
, name
, sym
);
349 struct sm_state
*get_sm_state_expr(int owner
, struct expression
*expr
)
353 struct sm_state
*ret
= NULL
;
355 expr
= strip_expr(expr
);
356 name
= expr_to_var_sym(expr
, &sym
);
359 ret
= get_sm_state(owner
, name
, sym
);
365 void delete_state(int owner
, const char *name
, struct symbol
*sym
)
367 delete_state_stree(&cur_stree
, owner
, name
, sym
);
368 if (cond_true_stack
) {
369 delete_state_stree_stack(&pre_cond_stack
, owner
, name
, sym
);
370 delete_state_stree_stack(&cond_true_stack
, owner
, name
, sym
);
371 delete_state_stree_stack(&cond_false_stack
, owner
, name
, sym
);
375 void delete_state_expr(int owner
, struct expression
*expr
)
380 expr
= strip_expr(expr
);
381 name
= expr_to_var_sym(expr
, &sym
);
384 delete_state(owner
, name
, sym
);
389 static void delete_all_states_stree_sym(struct stree
**stree
, struct symbol
*sym
)
391 struct state_list
*slist
= NULL
;
394 FOR_EACH_SM(*stree
, sm
) {
396 add_ptr_list(&slist
, sm
);
397 } END_FOR_EACH_SM(sm
);
399 FOR_EACH_PTR(slist
, sm
) {
400 delete_state_stree(stree
, sm
->owner
, sm
->name
, sm
->sym
);
401 } END_FOR_EACH_PTR(sm
);
406 static void delete_all_states_stree_stack_sym(struct stree_stack
**stack
, struct symbol
*sym
)
413 stree
= pop_stree(stack
);
414 delete_all_states_stree_sym(&stree
, sym
);
415 push_stree(stack
, stree
);
418 void __delete_all_states_sym(struct symbol
*sym
)
420 delete_all_states_stree_sym(&cur_stree
, sym
);
422 delete_all_states_stree_stack_sym(&true_stack
, sym
);
423 delete_all_states_stree_stack_sym(&true_stack
, sym
);
424 delete_all_states_stree_stack_sym(&false_stack
, sym
);
425 delete_all_states_stree_stack_sym(&pre_cond_stack
, sym
);
426 delete_all_states_stree_stack_sym(&cond_true_stack
, sym
);
427 delete_all_states_stree_stack_sym(&cond_false_stack
, sym
);
428 delete_all_states_stree_stack_sym(&fake_cur_stree_stack
, sym
);
429 delete_all_states_stree_stack_sym(&break_stack
, sym
);
430 delete_all_states_stree_stack_sym(&fake_break_stack
, sym
);
431 delete_all_states_stree_stack_sym(&switch_stack
, sym
);
432 delete_all_states_stree_stack_sym(&continue_stack
, sym
);
435 * deleting from the goto stack is problematic because we don't know
436 * if the label is in scope and also we need the value for --two-passes.
440 struct stree
*get_all_states_from_stree(int owner
, struct stree
*source
)
442 struct stree
*ret
= NULL
;
443 struct sm_state
*tmp
;
445 FOR_EACH_SM(source
, tmp
) {
446 if (tmp
->owner
== owner
)
447 avl_insert(&ret
, tmp
);
448 } END_FOR_EACH_SM(tmp
);
453 struct stree
*get_all_states_stree(int owner
)
455 return get_all_states_from_stree(owner
, cur_stree
);
458 struct stree
*__get_cur_stree(void)
463 int is_reachable(void)
470 void set_true_false_states(int owner
, const char *name
, struct symbol
*sym
,
471 struct smatch_state
*true_state
,
472 struct smatch_state
*false_state
)
475 sm_perror("cur_stree is read only.");
477 if (option_debug
|| strcmp(check_name(owner
), option_debug_check
) == 0) {
478 struct smatch_state
*tmp
;
480 tmp
= get_state(owner
, name
, sym
);
481 sm_msg("%s [%s] '%s'. Was %s. Now T:%s F:%s", __func__
,
482 check_name(owner
), name
, show_state(tmp
),
483 show_state(true_state
), show_state(false_state
));
489 if (!cond_false_stack
|| !cond_true_stack
) {
490 sm_perror("missing true/false stacks");
495 set_state_stree_stack(&cond_true_stack
, owner
, name
, sym
, true_state
);
497 set_state_stree_stack(&cond_false_stack
, owner
, name
, sym
, false_state
);
500 void set_true_false_states_expr(int owner
, struct expression
*expr
,
501 struct smatch_state
*true_state
,
502 struct smatch_state
*false_state
)
507 expr
= strip_expr(expr
);
508 name
= expr_to_var_sym(expr
, &sym
);
511 set_true_false_states(owner
, name
, sym
, true_state
, false_state
);
516 void __set_true_false_sm(struct sm_state
*true_sm
, struct sm_state
*false_sm
)
522 if (!true_sm
&& !false_sm
)
528 owner
= true_sm
? true_sm
->owner
: false_sm
->owner
;
529 name
= true_sm
? true_sm
->name
: false_sm
->name
;
530 sym
= true_sm
? true_sm
->sym
: false_sm
->sym
;
531 if (option_debug
|| strcmp(check_name(owner
), option_debug_check
) == 0) {
532 struct smatch_state
*tmp
;
534 tmp
= get_state(owner
, name
, sym
);
535 sm_msg("%s [%s] '%s'. Was %s. Now T:%s F:%s", __func__
,
536 check_name(owner
), name
, show_state(tmp
),
537 show_state(true_sm
? true_sm
->state
: NULL
),
538 show_state(false_sm
? false_sm
->state
: NULL
));
541 if (!cond_false_stack
|| !cond_true_stack
) {
542 sm_perror("missing true/false stacks");
547 overwrite_sm_state_stree_stack(&cond_true_stack
, true_sm
);
549 overwrite_sm_state_stree_stack(&cond_false_stack
, false_sm
);
552 void nullify_path(void)
554 if (fake_cur_stree_stack
) {
555 __free_fake_cur_stree();
556 __push_fake_cur_stree();
558 free_stree(&cur_stree
);
561 void __match_nullify_path_hook(const char *fn
, struct expression
*expr
,
568 * At the start of every function we mark the path
569 * as unnull. That way there is always at least one state
570 * in the cur_stree until nullify_path is called. This
571 * is used in merge_slist() for the first null check.
573 void __unnullify_path(void)
576 set_state(-1, "unnull_path", NULL
, &true_state
);
579 int __path_is_null(void)
586 static void check_stree_stack_free(struct stree_stack
**stack
)
589 sm_perror("stack not empty");
590 free_stack_and_strees(stack
);
594 void save_all_states(void)
596 __add_ptr_list(&backup
, cur_stree
, 0);
599 __add_ptr_list(&backup
, true_stack
, 0);
601 __add_ptr_list(&backup
, false_stack
, 0);
603 __add_ptr_list(&backup
, pre_cond_stack
, 0);
604 pre_cond_stack
= NULL
;
606 __add_ptr_list(&backup
, cond_true_stack
, 0);
607 cond_true_stack
= NULL
;
608 __add_ptr_list(&backup
, cond_false_stack
, 0);
609 cond_false_stack
= NULL
;
611 __add_ptr_list(&backup
, fake_cur_stree_stack
, 0);
612 fake_cur_stree_stack
= NULL
;
614 __add_ptr_list(&backup
, break_stack
, 0);
616 __add_ptr_list(&backup
, fake_break_stack
, 0);
617 fake_break_stack
= NULL
;
619 __add_ptr_list(&backup
, switch_stack
, 0);
621 __add_ptr_list(&backup
, remaining_cases
, 0);
622 remaining_cases
= NULL
;
623 __add_ptr_list(&backup
, default_stack
, 0);
624 default_stack
= NULL
;
625 __add_ptr_list(&backup
, continue_stack
, 0);
626 continue_stack
= NULL
;
628 __add_ptr_list(&backup
, goto_stack
, 0);
632 static void *pop_backup(void)
636 ret
= last_ptr_list(backup
);
637 delete_ptr_list_last(&backup
);
641 void restore_all_states(void)
643 goto_stack
= pop_backup();
645 continue_stack
= pop_backup();
646 default_stack
= pop_backup();
647 remaining_cases
= pop_backup();
648 switch_stack
= pop_backup();
649 fake_break_stack
= pop_backup();
650 break_stack
= pop_backup();
652 fake_cur_stree_stack
= pop_backup();
654 cond_false_stack
= pop_backup();
655 cond_true_stack
= pop_backup();
657 pre_cond_stack
= pop_backup();
658 false_stack
= pop_backup();
659 true_stack
= pop_backup();
661 cur_stree
= pop_backup();
664 void free_goto_stack(void)
666 struct named_stree
*named_stree
;
668 FOR_EACH_PTR(goto_stack
, named_stree
) {
669 free_stree(&named_stree
->stree
);
670 } END_FOR_EACH_PTR(named_stree
);
671 __free_ptr_list((struct ptr_list
**)&goto_stack
);
674 void clear_all_states(void)
677 check_stree_stack_free(&true_stack
);
678 check_stree_stack_free(&false_stack
);
679 check_stree_stack_free(&pre_cond_stack
);
680 check_stree_stack_free(&cond_true_stack
);
681 check_stree_stack_free(&cond_false_stack
);
682 check_stree_stack_free(&break_stack
);
683 check_stree_stack_free(&fake_break_stack
);
684 check_stree_stack_free(&switch_stack
);
685 check_stree_stack_free(&continue_stack
);
686 check_stree_stack_free(&fake_cur_stree_stack
);
690 free_every_single_sm_state();
691 free_tmp_expressions();
694 void __push_cond_stacks(void)
696 push_stree(&cond_true_stack
, NULL
);
697 push_stree(&cond_false_stack
, NULL
);
698 __push_fake_cur_stree();
701 void __fold_in_set_states(void)
703 struct stree
*new_states
;
706 new_states
= __pop_fake_cur_stree();
707 FOR_EACH_SM(new_states
, sm
) {
709 __set_true_false_sm(sm
, sm
);
710 } END_FOR_EACH_SM(sm
);
711 free_stree(&new_states
);
714 void __free_set_states(void)
716 struct stree
*new_states
;
718 new_states
= __pop_fake_cur_stree();
719 free_stree(&new_states
);
722 struct stree
*__copy_cond_true_states(void)
726 ret
= pop_stree(&cond_true_stack
);
727 push_stree(&cond_true_stack
, clone_stree(ret
));
731 struct stree
*__copy_cond_false_states(void)
735 ret
= pop_stree(&cond_false_stack
);
736 push_stree(&cond_false_stack
, clone_stree(ret
));
740 struct stree
*__pop_cond_true_stack(void)
742 return pop_stree(&cond_true_stack
);
745 struct stree
*__pop_cond_false_stack(void)
747 return pop_stree(&cond_false_stack
);
751 * This combines the pre cond states with either the true or false states.
753 * a = kmalloc() ; if (a !! foo(a)
754 * In the pre state a is possibly null. In the true state it is non null.
755 * In the false state it is null. Combine the pre and the false to get
756 * that when we call 'foo', 'a' is null.
758 static void __use_cond_stack(struct stree_stack
**stack
)
762 free_stree(&cur_stree
);
764 cur_stree
= pop_stree(&pre_cond_stack
);
765 push_stree(&pre_cond_stack
, clone_stree(cur_stree
));
767 stree
= pop_stree(stack
);
768 overwrite_stree(stree
, &cur_stree
);
769 push_stree(stack
, stree
);
772 void __use_pre_cond_states(void)
774 free_stree(&cur_stree
);
775 cur_stree
= pop_stree(&pre_cond_stack
);
778 void __use_cond_true_states(void)
780 __use_cond_stack(&cond_true_stack
);
783 void __use_cond_false_states(void)
785 __use_cond_stack(&cond_false_stack
);
788 void __negate_cond_stacks(void)
790 struct stree
*old_false
, *old_true
;
792 __use_cond_stack(&cond_false_stack
);
793 old_false
= pop_stree(&cond_false_stack
);
794 old_true
= pop_stree(&cond_true_stack
);
795 push_stree(&cond_false_stack
, old_true
);
796 push_stree(&cond_true_stack
, old_false
);
799 void __and_cond_states(void)
801 and_stree_stack(&cond_true_stack
);
802 or_stree_stack(&pre_cond_stack
, cur_stree
, &cond_false_stack
);
805 void __or_cond_states(void)
807 or_stree_stack(&pre_cond_stack
, cur_stree
, &cond_true_stack
);
808 and_stree_stack(&cond_false_stack
);
811 void __save_pre_cond_states(void)
813 push_stree(&pre_cond_stack
, clone_stree(cur_stree
));
816 void __discard_pre_cond_states(void)
820 tmp
= pop_stree(&pre_cond_stack
);
824 struct stree
*__get_true_states(void)
826 return clone_stree(top_stree(cond_true_stack
));
829 struct stree
*__get_false_states(void)
831 return clone_stree(top_stree(cond_false_stack
));
834 void __use_cond_states(void)
836 struct stree
*pre
, *pre_clone
, *true_states
, *false_states
;
838 pre
= pop_stree(&pre_cond_stack
);
839 pre_clone
= clone_stree(pre
);
841 true_states
= pop_stree(&cond_true_stack
);
842 overwrite_stree(true_states
, &pre
);
843 free_stree(&true_states
);
844 /* we use the true states right away */
845 free_stree(&cur_stree
);
848 false_states
= pop_stree(&cond_false_stack
);
849 overwrite_stree(false_states
, &pre_clone
);
850 free_stree(&false_states
);
851 push_stree(&false_stack
, pre_clone
);
854 void __push_true_states(void)
856 push_stree(&true_stack
, clone_stree(cur_stree
));
859 void __use_false_states(void)
861 free_stree(&cur_stree
);
862 cur_stree
= pop_stree(&false_stack
);
865 void __discard_false_states(void)
869 stree
= pop_stree(&false_stack
);
873 void __merge_false_states(void)
877 stree
= pop_stree(&false_stack
);
878 merge_stree(&cur_stree
, stree
);
883 * This function probably seemed common sensical when I wrote it but, oh wow,
884 * does it look subtle in retrospect. Say we set a state on one side of the if
885 * else path but not on the other, then what we should record in the fake stree
886 * is the merged state.
888 * This function relies on the fact that the we always set the cur_stree as well
889 * and we already have the infrastructure to merge things correctly into the
892 * So instead of merging fake strees together which is probably a lot of work,
893 * we just use it as a list of set states and look up the actual current values
897 static void update_stree_with_merged(struct stree
**stree
)
899 struct state_list
*slist
= NULL
;
900 struct sm_state
*sm
, *new;
902 FOR_EACH_SM(*stree
, sm
) {
903 new = get_sm_state(sm
->owner
, sm
->name
, sm
->sym
);
904 if (!new) /* This can happen if we go out of scope */
906 add_ptr_list(&slist
, new);
907 } END_FOR_EACH_SM(sm
);
909 FOR_EACH_PTR(slist
, sm
) {
910 overwrite_sm_state_stree(stree
, sm
);
911 } END_FOR_EACH_PTR(sm
);
916 static void update_fake_stree_with_merged(void)
920 if (!fake_cur_stree_stack
)
922 stree
= pop_stree(&fake_cur_stree_stack
);
923 update_stree_with_merged(&stree
);
924 push_stree(&fake_cur_stree_stack
, stree
);
927 void __merge_true_states(void)
931 stree
= pop_stree(&true_stack
);
932 merge_stree(&cur_stree
, stree
);
933 update_fake_stree_with_merged();
937 void __push_continues(void)
939 push_stree(&continue_stack
, NULL
);
942 void __discard_continues(void)
946 stree
= pop_stree(&continue_stack
);
950 void __process_continues(void)
954 stree
= pop_stree(&continue_stack
);
956 stree
= clone_stree(cur_stree
);
958 merge_stree(&stree
, cur_stree
);
960 push_stree(&continue_stack
, stree
);
963 void __merge_continues(void)
967 stree
= pop_stree(&continue_stack
);
968 merge_stree(&cur_stree
, stree
);
972 void __push_breaks(void)
974 push_stree(&break_stack
, NULL
);
975 if (fake_cur_stree_stack
)
976 push_stree(&fake_break_stack
, NULL
);
979 void __process_breaks(void)
983 stree
= pop_stree(&break_stack
);
985 stree
= clone_stree(cur_stree
);
987 merge_stree(&stree
, cur_stree
);
988 push_stree(&break_stack
, stree
);
990 if (!fake_cur_stree_stack
)
993 stree
= pop_stree(&fake_break_stack
);
995 stree
= clone_stree(top_stree(fake_cur_stree_stack
));
997 merge_stree(&stree
, top_stree(fake_cur_stree_stack
));
998 push_stree(&fake_break_stack
, stree
);
1001 int __has_breaks(void)
1003 struct stree
*stree
;
1006 stree
= pop_stree(&break_stack
);
1008 push_stree(&break_stack
, stree
);
1012 void __merge_breaks(void)
1014 struct stree
*stree
;
1015 struct sm_state
*sm
;
1017 stree
= pop_stree(&break_stack
);
1018 merge_stree(&cur_stree
, stree
);
1021 if (!fake_cur_stree_stack
)
1024 stree
= pop_stree(&fake_break_stack
);
1025 update_stree_with_merged(&stree
);
1026 FOR_EACH_SM(stree
, sm
) {
1027 overwrite_sm_state_stree_stack(&fake_cur_stree_stack
, sm
);
1028 } END_FOR_EACH_SM(sm
);
1032 void __use_breaks(void)
1034 struct stree
*stree
;
1035 struct sm_state
*sm
;
1037 free_stree(&cur_stree
);
1038 cur_stree
= pop_stree(&break_stack
);
1040 if (!fake_cur_stree_stack
)
1042 stree
= pop_stree(&fake_break_stack
);
1043 FOR_EACH_SM(stree
, sm
) {
1044 overwrite_sm_state_stree_stack(&fake_cur_stree_stack
, sm
);
1045 } END_FOR_EACH_SM(sm
);
1051 void __save_switch_states(struct expression
*switch_expr
)
1053 struct range_list
*rl
;
1055 get_absolute_rl(switch_expr
, &rl
);
1057 push_rl(&remaining_cases
, rl
);
1058 push_stree(&switch_stack
, clone_stree(cur_stree
));
1061 int have_remaining_cases(void)
1063 return !!top_rl(remaining_cases
);
1066 void __merge_switches(struct expression
*switch_expr
, struct range_list
*case_rl
)
1068 struct stree
*stree
;
1069 struct stree
*implied_stree
;
1071 stree
= pop_stree(&switch_stack
);
1072 implied_stree
= __implied_case_stree(switch_expr
, case_rl
, &remaining_cases
, &stree
);
1073 merge_stree(&cur_stree
, implied_stree
);
1074 free_stree(&implied_stree
);
1075 push_stree(&switch_stack
, stree
);
1078 void __discard_switches(void)
1080 struct stree
*stree
;
1082 pop_rl(&remaining_cases
);
1083 stree
= pop_stree(&switch_stack
);
1087 void __push_default(void)
1089 push_stree(&default_stack
, NULL
);
1092 void __set_default(void)
1094 set_state_stree_stack(&default_stack
, 0, "has_default", NULL
, &true_state
);
1097 int __pop_default(void)
1099 struct stree
*stree
;
1101 stree
= pop_stree(&default_stack
);
1109 static struct named_stree
*alloc_named_stree(const char *name
, struct symbol
*sym
, struct stree
*stree
)
1111 struct named_stree
*named_stree
= __alloc_named_stree(0);
1113 named_stree
->name
= (char *)name
;
1114 named_stree
->stree
= stree
;
1115 named_stree
->sym
= sym
;
1119 void __save_gotos(const char *name
, struct symbol
*sym
)
1121 struct stree
**stree
;
1122 struct stree
*clone
;
1124 stree
= get_named_stree(goto_stack
, name
, sym
);
1126 merge_stree(stree
, cur_stree
);
1129 struct named_stree
*named_stree
;
1131 clone
= clone_stree(cur_stree
);
1132 named_stree
= alloc_named_stree(name
, sym
, clone
);
1133 add_ptr_list(&goto_stack
, named_stree
);
1137 void __merge_gotos(const char *name
, struct symbol
*sym
)
1139 struct stree
**stree
;
1141 stree
= get_named_stree(goto_stack
, name
, sym
);
1143 merge_stree(&cur_stree
, *stree
);