11506 smatch resync

          --- old/usr/src/tools/smatch/src/smatch_returns.c
          +++ new/usr/src/tools/smatch/src/smatch_returns.c

   1    1  /*
   2    2   * Copyright (C) 2011 Oracle.
   3    3   *
   4    4   * This program is free software; you can redistribute it and/or
   5    5   * modify it under the terms of the GNU General Public License
   6    6   * as published by the Free Software Foundation; either version 2
   7    7   * of the License, or (at your option) any later version.
   8    8   *
   9    9   * This program is distributed in the hope that it will be useful,
  10   10   * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11   11   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12   12   * GNU General Public License for more details.
  13   13   *
  14   14   * You should have received a copy of the GNU General Public License
  15   15   * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
  16   16   */
  17   17  
  18   18  #include "smatch.h"
  19   19  #include "smatch_slist.h"
  20   20  #include "smatch_extra.h"
  21   21  
  22   22  int RETURN_ID;
  23   23  
  24   24  struct return_states_callback {
  25   25          void (*callback)(void);
  26   26  };
  27   27  ALLOCATOR(return_states_callback, "return states callbacks");
  28   28  DECLARE_PTR_LIST(callback_list, struct return_states_callback);
  29   29  static struct callback_list *callback_list;
  30   30  
  31   31  DECLARE_PTR_LIST(stree_stack_stack, struct stree_stack);
  32   32  static void push_stree_stack(struct stree_stack_stack **stack_stack, struct stree_stack *stack)
  33   33  {
  34   34          add_ptr_list(stack_stack, stack);
  35   35  }
  36   36  
  37   37  static struct stree_stack *pop_stree_stack(struct stree_stack_stack **stack_stack)
  38   38  {
  39   39          struct stree_stack *stack;
  40   40  
  41   41          stack = last_ptr_list((struct ptr_list *)*stack_stack);
  42   42          delete_ptr_list_last((struct ptr_list **)stack_stack);
  43   43          return stack;
  44   44  }
  45   45  
  46   46  static struct stree_stack *return_stree_stack;
  47   47  static struct stree_stack_stack *saved_stack_stack;
  48   48  static struct stree *all_return_states;
  49   49  static struct stree_stack *saved_stack;
  50   50  
  51   51  void all_return_states_hook(void (*callback)(void))
  52   52  {
  53   53          struct return_states_callback *rs_cb = __alloc_return_states_callback(0);
  54   54  
  55   55          rs_cb->callback = callback;
  56   56          add_ptr_list(&callback_list, rs_cb);
  57   57  }
  58   58  
  59   59  static void call_hooks(void)
  60   60  {
  61   61          struct return_states_callback *rs_cb;
  62   62  
  63   63          __set_fake_cur_stree_fast(all_return_states);
  64   64          FOR_EACH_PTR(callback_list, rs_cb) {
  65   65                  rs_cb->callback();
  66   66          } END_FOR_EACH_PTR(rs_cb);
  67   67          __pop_fake_cur_stree_fast();
  68   68  }
  69   69  
  70   70  static void match_return(int return_id, char *return_ranges, struct expression *expr)
  71   71  {
  72   72          struct stree *stree;
  73   73  
  74   74          stree = clone_stree(__get_cur_stree());
  75   75          merge_stree_no_pools(&all_return_states, stree);
  76   76          push_stree(&return_stree_stack, stree);
  77   77  }
  78   78  
  79   79  static void match_end_func(struct symbol *sym)
  80   80  {
  81   81          /*
  82   82           * FIXME: either this isn't needed or we need to copy a stree into the
  83   83           * return_stree_stack as well.
  84   84           */
  85   85          merge_stree(&all_return_states, __get_cur_stree());
  86   86          call_hooks();
  87   87  }
  88   88  
  89   89  static void match_save_states(struct expression *expr)
  90   90  {
  91   91          push_stree(&saved_stack, all_return_states);
  92   92          all_return_states = NULL;
  93   93  
  94   94          push_stree_stack(&saved_stack_stack, return_stree_stack);
  95   95          return_stree_stack = NULL;
  96   96  }
  97   97  
  98   98  static void match_restore_states(struct expression *expr)
  99   99  {
 100  100          /* This free_stree() isn't needed is it?? */
 101  101          free_stree(&all_return_states);
 102  102  
 103  103          all_return_states = pop_stree(&saved_stack);
 104  104          return_stree_stack = pop_stree_stack(&saved_stack_stack);
 105  105  }
 106  106  
 107  107  struct stree *get_all_return_states(void)
 108  108  {
 109  109          return all_return_states;
 110  110  }
 111  111  
 112  112  struct stree_stack *get_all_return_strees(void)
 113  113  {
 114  114          return return_stree_stack;
 115  115  }
 116  116  
 117  117  static void free_resources(struct symbol *sym)
 118  118  {
 119  119          struct stree *tmp;
 120  120  
 121  121          free_stree(&all_return_states);
 122  122  

 123  123          FOR_EACH_PTR(return_stree_stack, tmp) {
 124  124                  free_stree(&tmp);
 125  125          } END_FOR_EACH_PTR(tmp);
 126  126          free_stree_stack(&return_stree_stack);
 127  127  }
 128  128  
 129  129  void register_returns_early(int id)
 130  130  {
 131  131          RETURN_ID = id;
 132  132  
      133 +        set_dynamic_states(RETURN_ID);
 133  134          add_split_return_callback(match_return);
 134  135  }
 135  136  
 136  137  void register_returns(int id)
 137  138  {
 138  139          add_hook(&match_end_func, END_FUNC_HOOK);
 139  140          add_hook(&match_save_states, INLINE_FN_START);
 140  141          add_hook(&match_restore_states, INLINE_FN_END);
 141  142          add_hook(&free_resources, AFTER_FUNC_HOOK);
 142  143  }
    

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX