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 range_list_to_sval(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 static int rlists_equiv(struct related_list *one, struct related_list *two)
  61 {
  62         struct relation *one_rel;
  63         struct relation *two_rel;
  64
  65         PREPARE_PTR_LIST(one, one_rel);
  66         PREPARE_PTR_LIST(two, two_rel);
  67         for (;;) {
  68                 if (!one_rel && !two_rel)
  69                         return 1;
  70                 if (!one_rel || !two_rel)
  71                         return 0;
  72                 if (one_rel->sym != two_rel->sym)
  73                         return 0;
  74                 if (strcmp(one_rel->name, two_rel->name))
  75                         return 0;
  76                 NEXT_PTR_LIST(one_rel);
  77                 NEXT_PTR_LIST(two_rel);
  78         }
  79         FINISH_PTR_LIST(two_rel);
  80         FINISH_PTR_LIST(one_rel);
  81
  82         return 1;
  83 }
  84
  85 int estates_equiv(struct smatch_state *one, struct smatch_state *two)
  86 {
  87         if (one == two)
  88                 return 1;
  89         if (!rlists_equiv(estate_related(one), estate_related(two)))
  90                 return 0;
  91         if (strcmp(one->name, two->name) == 0)
  92                 return 1;
  93         return 0;
  94 }
  95
  96 static struct data_info *alloc_dinfo(void)
  97 {
  98         struct data_info *ret;
  99
 100         ret = __alloc_data_info(0);
 101         ret->related = NULL;
 102         ret->type = DATA_RANGE;
 103         ret->value_ranges = NULL;
 104         return ret;
 105 }
 106
 107 static struct data_info *alloc_dinfo_range(long long min, long long max)
 108 {
 109         struct data_info *ret;
 110
 111         ret = alloc_dinfo();
 112         add_range(&ret->value_ranges, min, max);
 113         return ret;
 114 }
 115
 116 static struct data_info *alloc_dinfo_range_list(struct range_list *rl)
 117 {
 118         struct data_info *ret;
 119
 120         ret = alloc_dinfo();
 121         ret->value_ranges = rl;
 122         return ret;
 123 }
 124
 125 static struct data_info *clone_dinfo(struct data_info *dinfo)
 126 {
 127         struct data_info *ret;
 128
 129         ret = alloc_dinfo();
 130         ret->related = clone_related_list(dinfo->related);
 131         ret->value_ranges = clone_range_list(dinfo->value_ranges);
 132         return ret;
 133 }
 134
 135 struct smatch_state *clone_estate(struct smatch_state *state)
 136 {
 137         struct smatch_state *ret;
 138
 139         ret = __alloc_smatch_state(0);
 140         ret->name = state->name;
 141         ret->data = clone_dinfo(get_dinfo(state));
 142         return ret;
 143 }
 144
 145 struct smatch_state *alloc_estate_empty(void)
 146 {
 147         struct smatch_state *state;
 148         struct data_info *dinfo;
 149
 150         dinfo = alloc_dinfo();
 151         state = __alloc_smatch_state(0);
 152         state->data = dinfo;
 153         state->name = "";
 154         return state;
 155 }
 156
 157 static struct smatch_state *alloc_estate_no_name(int val)
 158 {
 159         struct smatch_state *state;
 160
 161         state = __alloc_smatch_state(0);
 162         state->data = (void *)alloc_dinfo_range(val, val);
 163         return state;
 164 }
 165
 166 /* We do this because ->value_ranges is a list */
 167 struct smatch_state *extra_undefined(void)
 168 {
 169         return &estate_undefined;
 170 }
 171
 172 struct smatch_state *extra_empty(void)
 173 {
 174         struct smatch_state *ret;
 175
 176         ret = __alloc_smatch_state(0);
 177         ret->name = "empty";
 178         ret->data = alloc_dinfo();
 179         return ret;
 180 }
 181
 182 struct smatch_state *alloc_estate(long long val)
 183 {
 184         struct smatch_state *state;
 185
 186         state = alloc_estate_no_name(val);
 187         state->name = show_ranges(get_dinfo(state)->value_ranges);
 188         return state;
 189 }
 190
 191 struct smatch_state *alloc_estate_sval(sval_t sval)
 192 {
 193         struct smatch_state *state;
 194
 195         state = alloc_estate_no_name(sval.value);
 196         state->name = show_ranges(get_dinfo(state)->value_ranges);
 197         return state;
 198 }
 199
 200 struct smatch_state *alloc_estate_range(long long min, long long max)
 201 {
 202         struct smatch_state *state;
 203
 204         if (min == whole_range.min && max == whole_range.max)
 205                 return extra_undefined();
 206         state = __alloc_smatch_state(0);
 207         state->data = (void *)alloc_dinfo_range(min, max);
 208         state->name = show_ranges(get_dinfo(state)->value_ranges);
 209         return state;
 210 }
 211
 212 struct smatch_state *alloc_estate_range_sval(sval_t min, sval_t max)
 213 {
 214         struct smatch_state *state;
 215
 216         if (sval_is_min(min) && sval_is_max(max))
 217                 return extra_undefined();
 218         state = __alloc_smatch_state(0);
 219         state->data = (void *)alloc_dinfo_range(min.value, max.value);
 220         state->name = show_ranges(get_dinfo(state)->value_ranges);
 221         return state;
 222 }
 223
 224 struct smatch_state *alloc_estate_range_list(struct range_list *rl)
 225 {
 226         struct smatch_state *state;
 227
 228         if (!rl)
 229                 return extra_empty();
 230
 231         if (is_whole_range_rl(rl))
 232                 return extra_undefined();
 233
 234         state = __alloc_smatch_state(0);
 235         state->data = (void *)alloc_dinfo_range_list(rl);
 236         state->name = show_ranges(get_dinfo(state)->value_ranges);
 237         return state;
 238 }
 239
 240 struct smatch_state *alloc_estate_range_list_sval(struct range_list_sval *rl)
 241 {
 242         struct smatch_state *state;
 243
 244         if (!rl)
 245                 return extra_empty();
 246
 247         if (is_whole_range_rl_sval(rl))
 248                 return extra_undefined();
 249
 250         state = __alloc_smatch_state(0);
 251         state->data = (void *)alloc_dinfo_range_list(rl_sval_to_rl(rl));
 252         state->name = show_ranges_sval(rl);
 253         return state;
 254 }
 255
 256 void alloc_estate_undefined(void)
 257 {
 258         static struct data_info dinfo = {
 259                 .type = DATA_RANGE
 260         };
 261
 262         dinfo.value_ranges = clone_permanent(whole_range_list());
 263         estate_undefined.data = &dinfo;
 264 }