smatch_estate.c

   1 /*
   2  * smatch/smatch_dinfo.c
   3  *
   4  * Copyright (C) 2010 Dan Carpenter.
   5  *
   6  * Licensed under the Open Software License version 1.1
   7  *
   8  */
   9
  10 /*
  11  * smatch_dinfo.c has helper functions for handling data_info structs
  12  *
  13  */
  14
  15 #include <stdlib.h>
  16 #ifndef __USE_ISOC99
  17 #define __USE_ISOC99
  18 #endif
  19 #include <limits.h>
  20 #include "parse.h"
  21 #include "smatch.h"
  22 #include "smatch_slist.h"
  23 #include "smatch_extra.h"
  24
  25 struct smatch_state estate_undefined = {
  26         .name = "unknown"
  27 };
  28
  29 struct data_info *get_dinfo(struct smatch_state *state)
  30 {
  31         if (!state)
  32                 return NULL;
  33         return (struct data_info *)state->data;
  34 }
  35
  36 struct range_list_sval *estate_ranges_sval(struct smatch_state *state)
  37 {
  38         if (!state)
  39                 return NULL;
  40         return get_dinfo(state)->value_ranges;
  41 }
  42
  43 struct related_list *estate_related(struct smatch_state *state)
  44 {
  45         if (!state)
  46                 return NULL;
  47         return get_dinfo(state)->related;
  48 }
  49
  50 sval_t estate_min_sval(struct smatch_state *state)
  51 {
  52         return rl_min_sval(estate_ranges_sval(state));
  53 }
  54
  55 sval_t estate_max_sval(struct smatch_state *state)
  56 {
  57         return rl_max_sval(estate_ranges_sval(state));
  58 }
  59
  60 struct symbol *estate_type(struct smatch_state *state)
  61 {
  62         return rl_max_sval(estate_ranges_sval(state)).type;
  63 }
  64
  65 static int rlists_equiv(struct related_list *one, struct related_list *two)
  66 {
  67         struct relation *one_rel;
  68         struct relation *two_rel;
  69
  70         PREPARE_PTR_LIST(one, one_rel);
  71         PREPARE_PTR_LIST(two, two_rel);
  72         for (;;) {
  73                 if (!one_rel && !two_rel)
  74                         return 1;
  75                 if (!one_rel || !two_rel)
  76                         return 0;
  77                 if (one_rel->sym != two_rel->sym)
  78                         return 0;
  79                 if (strcmp(one_rel->name, two_rel->name))
  80                         return 0;
  81                 NEXT_PTR_LIST(one_rel);
  82                 NEXT_PTR_LIST(two_rel);
  83         }
  84         FINISH_PTR_LIST(two_rel);
  85         FINISH_PTR_LIST(one_rel);
  86
  87         return 1;
  88 }
  89
  90 int estates_equiv(struct smatch_state *one, struct smatch_state *two)
  91 {
  92         if (one == two)
  93                 return 1;
  94         if (!rlists_equiv(estate_related(one), estate_related(two)))
  95                 return 0;
  96         if (strcmp(one->name, two->name) == 0)
  97                 return 1;
  98         return 0;
  99 }
 100
 101 static struct data_info *alloc_dinfo(void)
 102 {
 103         struct data_info *ret;
 104
 105         ret = __alloc_data_info(0);
 106         ret->related = NULL;
 107         ret->type = DATA_RANGE;
 108         ret->value_ranges = NULL;
 109         return ret;
 110 }
 111
 112 static struct data_info *alloc_dinfo_range(sval_t min, sval_t max)
 113 {
 114         struct data_info *ret;
 115
 116         ret = alloc_dinfo();
 117         add_range_sval(&ret->value_ranges, min, max);
 118         return ret;
 119 }
 120
 121 static struct data_info *alloc_dinfo_range_list(struct range_list_sval *rl)
 122 {
 123         struct data_info *ret;
 124
 125         ret = alloc_dinfo();
 126         ret->value_ranges = rl;
 127         return ret;
 128 }
 129
 130 static struct data_info *clone_dinfo(struct data_info *dinfo)
 131 {
 132         struct data_info *ret;
 133
 134         ret = alloc_dinfo();
 135         ret->related = clone_related_list(dinfo->related);
 136         ret->value_ranges = clone_range_list_sval(dinfo->value_ranges);
 137         return ret;
 138 }
 139
 140 struct smatch_state *clone_estate(struct smatch_state *state)
 141 {
 142         struct smatch_state *ret;
 143
 144         ret = __alloc_smatch_state(0);
 145         ret->name = state->name;
 146         ret->data = clone_dinfo(get_dinfo(state));
 147         return ret;
 148 }
 149
 150 struct smatch_state *alloc_estate_empty(void)
 151 {
 152         struct smatch_state *state;
 153         struct data_info *dinfo;
 154
 155         dinfo = alloc_dinfo();
 156         state = __alloc_smatch_state(0);
 157         state->data = dinfo;
 158         state->name = "";
 159         return state;
 160 }
 161
 162 struct smatch_state *extra_undefined(struct symbol *type)
 163 {
 164         return alloc_estate_range_list_sval(whole_range_list_sval(type));
 165 }
 166
 167 struct smatch_state *extra_empty(void)
 168 {
 169         struct smatch_state *ret;
 170
 171         ret = __alloc_smatch_state(0);
 172         ret->name = "empty";
 173         ret->data = alloc_dinfo();
 174         return ret;
 175 }
 176
 177 struct smatch_state *alloc_estate_sval(sval_t sval)
 178 {
 179         struct smatch_state *state;
 180
 181         state = __alloc_smatch_state(0);
 182         state->data = alloc_dinfo_range(sval, sval);
 183         state->name = show_ranges_sval(get_dinfo(state)->value_ranges);
 184         return state;
 185 }
 186
 187 struct smatch_state *alloc_estate_range_sval(sval_t min, sval_t max)
 188 {
 189         struct smatch_state *state;
 190
 191         state = __alloc_smatch_state(0);
 192         state->data = alloc_dinfo_range(min, max);
 193         state->name = show_ranges_sval(get_dinfo(state)->value_ranges);
 194         return state;
 195 }
 196
 197 struct smatch_state *alloc_estate_range_list_sval(struct range_list_sval *rl)
 198 {
 199         struct smatch_state *state;
 200
 201         if (!rl)
 202                 return extra_empty();
 203
 204         state = __alloc_smatch_state(0);
 205         state->data = alloc_dinfo_range_list(rl);
 206         state->name = show_ranges_sval(rl);
 207         return state;
 208 }
 209
 210 void alloc_estate_undefined(void)
 211 {
 212         static struct data_info dinfo = {
 213                 .type = DATA_RANGE
 214         };
 215
 216         dinfo.value_ranges = clone_permanent_sval(whole_range_list_sval(&llong_ctype));
 217         estate_undefined.data = &dinfo;
 218 }