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