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