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_range whole_range = {
  26         .min = LLONG_MIN,
  27         .max = LLONG_MAX,
  28 };
  29
  30 struct data_info *get_dinfo(struct smatch_state *state)
  31 {
  32         if (!state)
  33                 return NULL;
  34         return (struct data_info *)state->data;
  35
  36 }
  37
  38 struct range_list *estate_ranges(struct smatch_state *state)
  39 {
  40         if (!state)
  41                 return NULL;
  42         return get_dinfo(state)->value_ranges;
  43 }
  44
  45 struct related_list *estate_related(struct smatch_state *state)
  46 {
  47         if (!state)
  48                 return NULL;
  49         return get_dinfo(state)->related;
  50 }
  51
  52 long long estate_min(struct smatch_state *state)
  53 {
  54         return rl_min(estate_ranges(state));
  55 }
  56
  57 long long estate_max(struct smatch_state *state)
  58 {
  59         return rl_max(estate_ranges(state));
  60 }
  61
  62 static struct data_info *alloc_dinfo(void)
  63 {
  64         struct data_info *ret;
  65
  66         ret = __alloc_data_info(0);
  67         ret->related = NULL;
  68         ret->type = DATA_RANGE;
  69         ret->value_ranges = NULL;
  70         return ret;
  71 }
  72
  73 static struct data_info *alloc_dinfo_range(long long min, long long max)
  74 {
  75         struct data_info *ret;
  76
  77         ret = alloc_dinfo();
  78         add_range(&ret->value_ranges, min, max);
  79         return ret;
  80 }
  81
  82 static struct data_info *alloc_dinfo_range_list(struct range_list *rl)
  83 {
  84         struct data_info *ret;
  85
  86         ret = alloc_dinfo();
  87         ret->value_ranges = rl;
  88         return ret;
  89 }
  90
  91 static struct data_info *clone_dinfo(struct data_info *dinfo)
  92 {
  93         struct data_info *ret;
  94
  95         ret = alloc_dinfo();
  96         ret->related = clone_related_list(dinfo->related);
  97         ret->value_ranges = clone_range_list(dinfo->value_ranges);
  98         return ret;
  99 }
 100
 101 struct smatch_state *clone_estate(struct smatch_state *state)
 102 {
 103         struct smatch_state *ret;
 104
 105         ret = __alloc_smatch_state(0);
 106         ret->name = state->name;
 107         ret->data = clone_dinfo(get_dinfo(state));
 108         return ret;
 109 }
 110
 111 struct smatch_state *alloc_estate_empty(void)
 112 {
 113         struct smatch_state *state;
 114         struct data_info *dinfo;
 115
 116         dinfo = alloc_dinfo();
 117         state = __alloc_smatch_state(0);
 118         state->data = dinfo;
 119         state->name = "";
 120         return state;
 121 }
 122
 123 static struct smatch_state *alloc_estate_no_name(int val)
 124 {
 125         struct smatch_state *state;
 126
 127         state = __alloc_smatch_state(0);
 128         state->data = (void *)alloc_dinfo_range(val, val);
 129         return state;
 130 }
 131
 132 /* We do this because ->value_ranges is a list */
 133 struct smatch_state *extra_undefined(void)
 134 {
 135         struct data_info *dinfo;
 136         static struct smatch_state *ret;
 137         static struct symbol *prev_func;
 138
 139         if  (prev_func == cur_func_sym)
 140                 return ret;
 141         prev_func = cur_func_sym;
 142
 143         dinfo = alloc_dinfo_range(whole_range.min, whole_range.max);
 144         ret = __alloc_smatch_state(0);
 145         ret->name = "unknown";
 146         ret->data = dinfo;
 147         return ret;
 148 }
 149
 150 struct smatch_state *extra_empty(void)
 151 {
 152         static struct smatch_state *ret;
 153         static struct symbol *prev_func;
 154
 155         if  (prev_func == cur_func_sym)
 156                 return ret;
 157         prev_func = cur_func_sym;
 158
 159         ret = __alloc_smatch_state(0);
 160         ret->name = "empty";
 161         ret->data = alloc_dinfo();
 162         return ret;
 163 }
 164
 165 struct smatch_state *alloc_estate(long long val)
 166 {
 167         struct smatch_state *state;
 168
 169         state = alloc_estate_no_name(val);
 170         state->name = show_ranges(get_dinfo(state)->value_ranges);
 171         return state;
 172 }
 173
 174 struct smatch_state *alloc_estate_range(long long min, long long max)
 175 {
 176         struct smatch_state *state;
 177
 178         if (min == whole_range.min && max == whole_range.max)
 179                 return extra_undefined();
 180         state = __alloc_smatch_state(0);
 181         state->data = (void *)alloc_dinfo_range(min, max);
 182         state->name = show_ranges(get_dinfo(state)->value_ranges);
 183         return state;
 184 }
 185
 186 struct smatch_state *alloc_estate_range_list(struct range_list *rl)
 187 {
 188         struct smatch_state *state;
 189
 190         if (!rl)
 191                 return extra_empty();
 192
 193         if (is_whole_range_rl(rl))
 194                 return extra_undefined();
 195
 196         state = __alloc_smatch_state(0);
 197         state->data = (void *)alloc_dinfo_range_list(rl);
 198         state->name = show_ranges(get_dinfo(state)->value_ranges);
 199         return state;
 200 }
 201