11972 resync smatch

*** 42,51 ****
--- 42,52 ----
  struct smatch_state merged = { .name = "merged" };
  struct smatch_state true_state = { .name = "true" };
  struct smatch_state false_state = { .name = "false" };
  
  static struct stree *cur_stree; /* current states */
+ static struct stree *fast_overlay;
  
  static struct stree_stack *true_stack; /* states after a t/f branch */
  static struct stree_stack *false_stack;
  static struct stree_stack *pre_cond_stack; /* states before a t/f branch */
  
*** 78,87 ****
--- 79,98 ----
          if (!cur_stree)
                  return 1;
          return 0;
  }
  
+ void __set_cur_stree_readonly(void)
+ {
+         read_only++;
+ }
+ 
+ void __set_cur_stree_writable(void)
+ {
+         read_only--;
+ }
+ 
  struct sm_state *set_state(int owner, const char *name, struct symbol *sym, struct smatch_state *state)
  {
          struct sm_state *ret;
  
          if (!name || !state)
*** 128,141 ****
  free:
          free_string(name);
          return ret;
  }
  
! void __swap_cur_stree(struct stree *stree)
  {
!         free_stree(&cur_stree);
          cur_stree = stree;
  }
  
  void __push_fake_cur_stree(void)
  {
          push_stree(&fake_cur_stree_stack, NULL);
--- 139,154 ----
  free:
          free_string(name);
          return ret;
  }
  
! struct stree *__swap_cur_stree(struct stree *stree)
  {
!         struct stree *orig = cur_stree;
! 
          cur_stree = stree;
+         return orig;
  }
  
  void __push_fake_cur_stree(void)
  {
          push_stree(&fake_cur_stree_stack, NULL);
*** 158,176 ****
          free_stree(&stree);
  }
  
  void __set_fake_cur_stree_fast(struct stree *stree)
  {
!         push_stree(&pre_cond_stack, cur_stree);
!         cur_stree = stree;
!         read_only = 1;
  }
  
  void __pop_fake_cur_stree_fast(void)
  {
!         cur_stree = pop_stree(&pre_cond_stack);
!         read_only = 0;
  }
  
  void __merge_stree_into_cur(struct stree *stree)
  {
          struct sm_state *sm;
--- 171,192 ----
          free_stree(&stree);
  }
  
  void __set_fake_cur_stree_fast(struct stree *stree)
  {
!         if (fast_overlay) {
!                 sm_perror("cannot nest fast overlay");
!                 return;
!         }
!         fast_overlay = stree;
!         set_fast_math_only();
  }
  
  void __pop_fake_cur_stree_fast(void)
  {
!         fast_overlay = NULL;
!         clear_fast_math_only();
  }
  
  void __merge_stree_into_cur(struct stree *stree)
  {
          struct sm_state *sm;
*** 287,297 ****
          recursion = 0;
  }
  
  struct smatch_state *__get_state(int owner, const char *name, struct symbol *sym)
  {
!         return get_state_stree(cur_stree, owner, name, sym);
  }
  
  struct smatch_state *get_state(int owner, const char *name, struct symbol *sym)
  {
          call_get_state_hooks(owner, name, sym);
--- 303,318 ----
          recursion = 0;
  }
  
  struct smatch_state *__get_state(int owner, const char *name, struct symbol *sym)
  {
!         struct sm_state *sm;
! 
!         sm = get_sm_state(owner, name, sym);
!         if (!sm)
!                 return NULL;
!         return sm->state;
  }
  
  struct smatch_state *get_state(int owner, const char *name, struct symbol *sym)
  {
          call_get_state_hooks(owner, name, sym);
*** 341,350 ****
--- 362,377 ----
          return ret;
  }
  
  struct sm_state *get_sm_state(int owner, const char *name, struct symbol *sym)
  {
+         struct sm_state *ret;
+ 
+         ret = get_sm_state_stree(fast_overlay, owner, name, sym);
+         if (ret)
+                 return ret;
+ 
          return get_sm_state_stree(cur_stree, owner, name, sym);
  }
  
  struct sm_state *get_sm_state_expr(int owner, struct expression *expr)
  {
*** 591,633 ****
          }
  }
  
  void save_all_states(void)
  {
!         __add_ptr_list(&backup, cur_stree, 0);
          cur_stree = NULL;
  
!         __add_ptr_list(&backup, true_stack, 0);
          true_stack = NULL;
!         __add_ptr_list(&backup, false_stack, 0);
          false_stack = NULL;
!         __add_ptr_list(&backup, pre_cond_stack, 0);
          pre_cond_stack = NULL;
  
!         __add_ptr_list(&backup, cond_true_stack, 0);
          cond_true_stack = NULL;
!         __add_ptr_list(&backup, cond_false_stack, 0);
          cond_false_stack = NULL;
  
!         __add_ptr_list(&backup, fake_cur_stree_stack, 0);
          fake_cur_stree_stack = NULL;
  
!         __add_ptr_list(&backup, break_stack, 0);
          break_stack = NULL;
!         __add_ptr_list(&backup, fake_break_stack, 0);
          fake_break_stack = NULL;
  
!         __add_ptr_list(&backup, switch_stack, 0);
          switch_stack = NULL;
!         __add_ptr_list(&backup, remaining_cases, 0);
          remaining_cases = NULL;
!         __add_ptr_list(&backup, default_stack, 0);
          default_stack = NULL;
!         __add_ptr_list(&backup, continue_stack, 0);
          continue_stack = NULL;
  
!         __add_ptr_list(&backup, goto_stack, 0);
          goto_stack = NULL;
  }
  
  static void *pop_backup(void)
  {
--- 618,660 ----
          }
  }
  
  void save_all_states(void)
  {
!         __add_ptr_list(&backup, cur_stree);
          cur_stree = NULL;
  
!         __add_ptr_list(&backup, true_stack);
          true_stack = NULL;
!         __add_ptr_list(&backup, false_stack);
          false_stack = NULL;
!         __add_ptr_list(&backup, pre_cond_stack);
          pre_cond_stack = NULL;
  
!         __add_ptr_list(&backup, cond_true_stack);
          cond_true_stack = NULL;
!         __add_ptr_list(&backup, cond_false_stack);
          cond_false_stack = NULL;
  
!         __add_ptr_list(&backup, fake_cur_stree_stack);
          fake_cur_stree_stack = NULL;
  
!         __add_ptr_list(&backup, break_stack);
          break_stack = NULL;
!         __add_ptr_list(&backup, fake_break_stack);
          fake_break_stack = NULL;
  
!         __add_ptr_list(&backup, switch_stack);
          switch_stack = NULL;
!         __add_ptr_list(&backup, remaining_cases);
          remaining_cases = NULL;
!         __add_ptr_list(&backup, default_stack);
          default_stack = NULL;
!         __add_ptr_list(&backup, continue_stack);
          continue_stack = NULL;
  
!         __add_ptr_list(&backup, goto_stack);
          goto_stack = NULL;
  }
  
  static void *pop_backup(void)
  {