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 smatch_state *ret;
 131
 132         ret = __alloc_smatch_state(0);
 133         ret->data = alloc_dinfo_range(whole_range.min, whole_range.max);
 134         ret->name = "unknown";
 135         return ret;
 136 }
 137
 138 struct smatch_state *extra_empty(void)
 139 {
 140         struct smatch_state *ret;
 141
 142         ret = __alloc_smatch_state(0);
 143         ret->name = "empty";
 144         ret->data = alloc_dinfo();
 145         return ret;
 146 }
 147
 148 struct smatch_state *alloc_estate(long long val)
 149 {
 150         struct smatch_state *state;
 151
 152         state = alloc_estate_no_name(val);
 153         state->name = show_ranges(get_dinfo(state)->value_ranges);
 154         return state;
 155 }
 156
 157 struct smatch_state *alloc_estate_range(long long min, long long max)
 158 {
 159         struct smatch_state *state;
 160
 161         if (min == whole_range.min && max == whole_range.max)
 162                 return extra_undefined();
 163         state = __alloc_smatch_state(0);
 164         state->data = (void *)alloc_dinfo_range(min, max);
 165         state->name = show_ranges(get_dinfo(state)->value_ranges);
 166         return state;
 167 }
 168
 169 struct smatch_state *alloc_estate_range_list(struct range_list *rl)
 170 {
 171         struct smatch_state *state;
 172
 173         if (!rl)
 174                 return extra_empty();
 175
 176         if (is_whole_range_rl(rl))
 177                 return extra_undefined();
 178
 179         state = __alloc_smatch_state(0);
 180         state->data = (void *)alloc_dinfo_range_list(rl);
 181         state->name = show_ranges(get_dinfo(state)->value_ranges);
 182         return state;
 183 }
 184