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