12724 update smatch to 0.6.1-rc1-il-5

          --- old/usr/src/tools/smatch/src/smatch_extra.h
          +++ new/usr/src/tools/smatch/src/smatch_extra.h

   1    1  /*
   2    2   * Copyright (C) 2009 Dan Carpenter.
   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  DECLARE_PTR_LIST(range_list, struct data_range);
  19   19  DECLARE_PTR_LIST(range_list_stack, struct range_list);
  20   20  
  21   21  struct relation {
  22   22          char *name;
  23   23          struct symbol *sym;
  24   24  };

  25   25  
  26   26  DECLARE_PTR_LIST(related_list, struct relation);
  27   27  
  28   28  struct data_info {
  29   29          struct related_list *related;
  30   30          struct range_list *value_ranges;
  31   31          sval_t fuzzy_max;
  32   32          unsigned int hard_max:1;
  33   33          unsigned int capped:1;
  34   34          unsigned int treat_untagged:1;
       35 +        unsigned int set:1;
  35   36  };
  36   37  DECLARE_ALLOCATOR(data_info);
  37   38  
  38   39  extern struct string_list *__ignored_macros;
  39   40  
  40   41  /* these are implemented in smatch_ranges.c */
  41   42  struct range_list *rl_zero(void);
  42   43  struct range_list *rl_one(void);
  43   44  char *show_rl(struct range_list *list);
  44   45  int str_to_comparison_arg(const char *c, struct expression *call, int *comparison, struct expression **arg);

  45   46  void str_to_rl(struct symbol *type, char *value, struct range_list **rl);
  46   47  void call_results_to_rl(struct expression *call, struct symbol *type, const char *value, struct range_list **rl);
  47   48  
  48   49  struct data_range *alloc_range(sval_t min, sval_t max);
  49   50  struct data_range *alloc_range_perm(sval_t min, sval_t max);
  50   51  
  51   52  int rl_fits_in_type(struct range_list *rl, struct symbol *type);
  52   53  
  53   54  struct range_list *alloc_rl(sval_t min, sval_t max);
  54   55  struct range_list *clone_rl(struct range_list *list);
  55   56  struct range_list *clone_rl_permanent(struct range_list *list);
  56   57  struct range_list *alloc_whole_rl(struct symbol *type);
  57   58  
  58   59  void add_range(struct range_list **list, sval_t min, sval_t max);
  59   60  struct range_list *remove_range(struct range_list *list, sval_t min, sval_t max);
  60   61  void tack_on(struct range_list **list, struct data_range *drange);
  61   62  
  62   63  int true_comparison_range(struct data_range *left, int comparison, struct data_range *right);
  63   64  int true_comparison_range_LR(int comparison, struct data_range *var, struct data_range *val, int left);
  64   65  int false_comparison_range_LR(int comparison, struct data_range *var, struct data_range *val, int left);
  65   66  
  66   67  int possibly_true(struct expression *left, int comparison, struct expression *right);
  67   68  int possibly_true_rl(struct range_list *left_ranges, int comparison, struct range_list *right_ranges);
  68   69  int possibly_true_rl_LR(int comparison, struct range_list *a, struct range_list *b, int left);
  69   70  
  70   71  int possibly_false(struct expression *left, int comparison, struct expression *right);
  71   72  int possibly_false_rl(struct range_list *left_ranges, int comparison, struct range_list *right_ranges);
  72   73  int possibly_false_rl_LR(int comparison, struct range_list *a, struct range_list *b, int left);
  73   74  
  74   75  int rl_has_sval(struct range_list *rl, sval_t sval);
  75   76  int ranges_equiv(struct data_range *one, struct data_range *two);
  76   77  
  77   78  bool is_err_ptr(sval_t sval);
  78   79  
  79   80  int rl_equiv(struct range_list *one, struct range_list *two);
  80   81  int is_whole_rl(struct range_list *rl);
  81   82  int is_unknown_ptr(struct range_list *rl);
  82   83  int is_whole_rl_non_zero(struct range_list *rl);
  83   84  int estate_is_unknown(struct smatch_state *state);
  84   85  
  85   86  sval_t rl_min(struct range_list *rl);
  86   87  sval_t rl_max(struct range_list *rl);
  87   88  int rl_to_sval(struct range_list *rl, sval_t *sval);
  88   89  struct symbol *rl_type(struct range_list *rl);
  89   90  
  90   91  struct range_list *rl_filter(struct range_list *rl, struct range_list *filter);
  91   92  struct range_list *rl_intersection(struct range_list *one, struct range_list *two);
  92   93  struct range_list *rl_union(struct range_list *one, struct range_list *two);
  93   94  struct range_list *rl_binop(struct range_list *left, int op, struct range_list *right);

  94   95  
  95   96  void push_rl(struct range_list_stack **rl_stack, struct range_list *rl);
  96   97  struct range_list *pop_rl(struct range_list_stack **rl_stack);
  97   98  struct range_list *top_rl(struct range_list_stack *rl_stack);
  98   99  void filter_top_rl(struct range_list_stack **rl_stack, struct range_list *filter);
  99  100  
 100  101  struct range_list *rl_truncate_cast(struct symbol *type, struct range_list *rl);
 101  102  struct range_list *cast_rl(struct symbol *type, struct range_list *rl);
 102  103  int get_implied_rl(struct expression *expr, struct range_list **rl);
 103  104  int get_absolute_rl(struct expression *expr, struct range_list **rl);
      105 +void set_real_absolute(struct expression *expr, struct smatch_state *state);
 104  106  int get_real_absolute_rl(struct expression *expr, struct range_list **rl);
 105  107  struct range_list *var_to_absolute_rl(struct expression *expr);
 106  108  int custom_get_absolute_rl(struct expression *expr,
 107  109                             struct range_list *(*fn)(struct expression *expr),
 108  110                             struct range_list **rl);
 109  111  int get_implied_rl_var_sym(const char *var, struct symbol *sym, struct range_list **rl);
 110  112  void split_comparison_rl(struct range_list *left_orig, int op, struct range_list *right_orig,
 111  113                  struct range_list **left_true_rl, struct range_list **left_false_rl,
 112  114                  struct range_list **right_true_rl, struct range_list **right_false_rl);
 113  115  

 114  116  void free_data_info_allocs(void);
 115  117  void free_all_rl(void);
 116  118  
 117  119  /* smatch_estate.c */
 118  120  
 119  121  struct smatch_state *alloc_estate_empty(void);
 120  122  struct smatch_state *alloc_estate_sval(sval_t sval);
 121  123  struct smatch_state *alloc_estate_range(sval_t min, sval_t max);
 122  124  struct smatch_state *alloc_estate_rl(struct range_list *rl);
 123  125  struct smatch_state *alloc_estate_whole(struct symbol *type);
 124  126  struct smatch_state *clone_estate(struct smatch_state *state);
 125  127  struct smatch_state *clone_estate_cast(struct symbol *type, struct smatch_state *state);
 126  128  struct smatch_state *clone_partial_estate(struct smatch_state *state, struct range_list *rl);
 127  129  
 128  130  struct smatch_state *merge_estates(struct smatch_state *s1, struct smatch_state *s2);
 129  131  
 130  132  int estates_equiv(struct smatch_state *one, struct smatch_state *two);
 131  133  int estate_is_whole(struct smatch_state *state);
 132  134  int estate_is_empty(struct smatch_state *state);
 133  135  
 134  136  struct range_list *estate_rl(struct smatch_state *state);
 135  137  struct related_list *estate_related(struct smatch_state *state);
 136  138  
 137  139  sval_t estate_min(struct smatch_state *state);
 138  140  sval_t estate_max(struct smatch_state *state);
 139  141  struct symbol *estate_type(struct smatch_state *state);
 140  142  
 141  143  int estate_has_fuzzy_max(struct smatch_state *state);
 142  144  sval_t estate_get_fuzzy_max(struct smatch_state *state);
 143  145  void estate_set_fuzzy_max(struct smatch_state *state, sval_t max);

 144  146  void estate_copy_fuzzy_max(struct smatch_state *new, struct smatch_state *old);
 145  147  void estate_clear_fuzzy_max(struct smatch_state *state);
 146  148  int estate_has_hard_max(struct smatch_state *state);
 147  149  void estate_set_hard_max(struct smatch_state *state);
 148  150  void estate_clear_hard_max(struct smatch_state *state);
 149  151  int estate_get_hard_max(struct smatch_state *state, sval_t *sval);
 150  152  bool estate_capped(struct smatch_state *state);
 151  153  void estate_set_capped(struct smatch_state *state);
 152  154  bool estate_treat_untagged(struct smatch_state *state);
 153  155  void estate_set_treat_untagged(struct smatch_state *state);
      156 +bool estate_new(struct smatch_state *state);
      157 +void estate_set_new(struct smatch_state *state);
 154  158  
 155  159  int estate_get_single_value(struct smatch_state *state, sval_t *sval);
 156  160  struct smatch_state *get_implied_estate(struct expression *expr);
 157  161  
 158  162  struct smatch_state *estate_filter_sval(struct smatch_state *orig, sval_t filter);
 159  163  struct data_info *clone_dinfo_perm(struct data_info *dinfo);
 160  164  struct smatch_state *clone_estate_perm(struct smatch_state *state);
 161  165  
 162  166  /* smatch_extra.c */
 163  167  bool is_impossible_variable(struct expression *expr);

 164  168  struct sm_state *get_extra_sm_state(struct expression *expr);
 165  169  struct smatch_state *get_extra_state(struct expression *expr);
 166  170  void call_extra_mod_hooks(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state);
 167  171  void set_extra_mod(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state);
 168  172  void set_extra_expr_mod(struct expression *expr, struct smatch_state *state);
 169  173  void set_extra_nomod(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state);
 170  174  void set_extra_nomod_vsl(const char *name, struct symbol *sym, struct var_sym_list *vsl, struct expression *expr, struct smatch_state *state);
 171  175  void set_extra_expr_nomod(struct expression *expr, struct smatch_state *state);
 172  176  void set_extra_mod_helper(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state);
 173  177  
 174  178  struct data_info *get_dinfo(struct smatch_state *state);
 175  179  
 176  180  void add_extra_mod_hook(void (*fn)(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state));
 177  181  void add_extra_nomod_hook(void (*fn)(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state));
 178  182  int implied_not_equal(struct expression *expr, long long val);
 179  183  int implied_not_equal_name_sym(char *name, struct symbol *sym, long long val);
 180  184  int parent_is_null_var_sym(const char *name, struct symbol *sym);
 181  185  int parent_is_null(struct expression *expr);
 182  186  int parent_is_free_var_sym_strict(const char *name, struct symbol *sym);
 183  187  int parent_is_free_var_sym(const char *name, struct symbol *sym);
 184  188  int parent_is_free(struct expression *expr);
 185  189  
 186  190  struct sm_state *__extra_handle_canonical_loops(struct statement *loop, struct stree **stree);
 187  191  int __iterator_unchanged(struct sm_state *sm);
 188  192  void __extra_pre_loop_hook_after(struct sm_state *sm,
 189  193                                  struct statement *iterator,
 190  194                                  struct expression *condition);
 191  195  
 192  196  /* smatch_equiv.c */
 193  197  void set_equiv(struct expression *left, struct expression *right);
 194  198  void set_related(struct smatch_state *estate, struct related_list *rlist);
 195  199  struct related_list *get_shared_relations(struct related_list *one,
 196  200                                                struct related_list *two);
 197  201  struct related_list *clone_related_list(struct related_list *related);
 198  202  void remove_from_equiv(const char *name, struct symbol *sym);
 199  203  void remove_from_equiv_expr(struct expression *expr);
 200  204  void set_equiv_state_expr(int id, struct expression *expr, struct smatch_state *state);
 201  205  
 202  206  /* smatch_function_hooks.c */
 203  207  void function_comparison(struct expression *left, int comparison, struct expression *right);
 204  208  
 205  209  /* smatch_expressions.c */
 206  210  struct expression *zero_expr();
 207  211  struct expression *value_expr(long long val);
 208  212  struct expression *member_expression(struct expression *deref, int op, struct ident *member);
 209  213  struct expression *preop_expression(struct expression *expr, int op);
 210  214  struct expression *deref_expression(struct expression *expr);
 211  215  struct expression *assign_expression(struct expression *left, int op, struct expression *right);
 212  216  struct expression *binop_expression(struct expression *left, int op, struct expression *right);
 213  217  struct expression *array_element_expression(struct expression *array, struct expression *offset);
 214  218  struct expression *symbol_expression(struct symbol *sym);
 215  219  struct expression *string_expression(char *str);
 216  220  struct expression *compare_expression(struct expression *left, int op, struct expression *right);
 217  221  struct expression *call_expression(struct expression *fn, struct expression_list *args);
 218  222  struct expression *unknown_value_expression(struct expression *expr);
 219  223  int is_fake_call(struct expression *expr);
 220  224  struct expression *gen_expression_from_name_sym(const char *name, struct symbol *sym);
 221  225  struct expression *gen_expression_from_key(struct expression *arg, const char *key);
 222  226  void free_tmp_expressions(void);
 223  227  void expr_set_parent_expr(struct expression *expr, struct expression *parent);
 224  228  void expr_set_parent_stmt(struct expression *expr, struct statement *parent);
 225  229  struct expression *expr_get_parent_expr(struct expression *expr);
 226  230  struct statement *expr_get_parent_stmt(struct expression *expr);
 227  231  
 228  232  /* smatch_param_limit.c */
 229  233  struct smatch_state *get_orig_estate(const char *name, struct symbol *sym);
 230  234  
 231  235  /* smatch_real_absolute.c */
 232  236  struct smatch_state *get_real_absolute_state(struct expression *expr);
 233  237  struct smatch_state *get_real_absolute_state_var_sym(const char *name, struct symbol *sym);
 234  238  
 235  239  /* smatch_imaginary_absolute.c */
 236  240  void __save_imaginary_state(struct expression *expr, struct range_list *true_rl, struct range_list *false_rl);
 237  241  int get_imaginary_absolute(struct expression *expr, struct range_list **rl);
 238  242  

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX