smatch_type.c

   1 /*
   2  * sparse/smatch_types.c
   3  *
   4  * Copyright (C) 2009 Dan Carpenter.
   5  *
   6  * Licensed under the Open Software License version 1.1
   7  *
   8  */
   9
  10 /*
  11  * The idea here is that you have an expression and you
  12  * want to know what the type is for that.
  13  */
  14
  15 #include "smatch.h"
  16
  17 struct symbol *get_real_base_type(struct symbol *sym)
  18 {
  19         struct symbol *ret;
  20
  21         ret = get_base_type(sym);
  22         if (ret && ret->type == SYM_RESTRICT)
  23                 return get_real_base_type(ret);
  24         return ret;
  25 }
  26
  27 static struct symbol *get_binop_type(struct expression *expr)
  28 {
  29         struct symbol *left, *right;
  30         sval_t left_max, right_max, int_max;
  31
  32         left = get_type(expr->left);
  33         right = get_type(expr->right);
  34
  35         if (!left || !right)
  36                 return NULL;
  37
  38         if (left->type == SYM_PTR || left->type == SYM_ARRAY)
  39                 return left;
  40         if (right->type == SYM_PTR || right->type == SYM_ARRAY)
  41                 return right;
  42
  43         left_max = sval_type_max(left);
  44         right_max = sval_type_max(right);
  45         int_max = sval_type_max(&int_ctype);
  46
  47         if (expr->op == SPECIAL_LEFTSHIFT ||
  48             expr->op == SPECIAL_RIGHTSHIFT) {
  49                 if (sval_cmp(left_max, int_max) < 0)
  50                         return &int_ctype;
  51                 return left;
  52         }
  53
  54         if (sval_cmp(left_max, int_max) < 0 &&
  55             sval_cmp(right_max, int_max) < 0)
  56                 return &int_ctype;
  57
  58         if (sval_cmp(right_max, left_max) > 0)
  59                 return right;
  60         return left;
  61 }
  62
  63 static struct symbol *get_type_symbol(struct expression *expr)
  64 {
  65         if (!expr || expr->type != EXPR_SYMBOL || !expr->symbol)
  66                 return NULL;
  67
  68         return get_real_base_type(expr->symbol);
  69 }
  70
  71 static struct symbol *get_symbol_from_deref(struct expression *expr)
  72 {
  73         struct ident *member;
  74         struct symbol *struct_sym;
  75         struct symbol *tmp;
  76
  77         if (!expr || expr->type != EXPR_DEREF)
  78                 return NULL;
  79
  80         member = expr->member;
  81         struct_sym = get_type(expr->deref);
  82         if (!struct_sym) {
  83                 // sm_msg("could not find struct type");
  84                 return NULL;
  85         }
  86         if (struct_sym->type == SYM_PTR)
  87                 struct_sym = get_real_base_type(struct_sym);
  88         FOR_EACH_PTR(struct_sym->symbol_list, tmp) {
  89                 if (tmp->ident == member)
  90                         return get_real_base_type(tmp);
  91         } END_FOR_EACH_PTR(tmp);
  92         return NULL;
  93 }
  94
  95 static struct symbol *get_return_type(struct expression *expr)
  96 {
  97         struct symbol *tmp;
  98
  99         tmp = get_type(expr->fn);
 100         if (!tmp)
 101                 return NULL;
 102         return get_real_base_type(tmp);
 103 }
 104
 105 struct symbol *get_pointer_type(struct expression *expr)
 106 {
 107         struct symbol *sym;
 108
 109         sym = get_type(expr);
 110         if (!sym || (sym->type != SYM_PTR && sym->type != SYM_ARRAY))
 111                 return NULL;
 112         return get_real_base_type(sym);
 113 }
 114
 115 static struct symbol *fake_pointer_sym(struct expression *expr)
 116 {
 117         struct symbol *sym;
 118         struct symbol *base;
 119
 120         sym = alloc_symbol(expr->pos, SYM_PTR);
 121         expr = expr->unop;
 122         base = get_type(expr);
 123         if (!base)
 124                 return NULL;
 125         sym->ctype.base_type = base;
 126         return sym;
 127 }
 128
 129 struct symbol *get_type(struct expression *expr)
 130 {
 131         if (!expr)
 132                 return NULL;
 133         expr = strip_parens(expr);
 134
 135         switch (expr->type) {
 136         case EXPR_SYMBOL:
 137                 return get_type_symbol(expr);
 138         case EXPR_DEREF:
 139                 return get_symbol_from_deref(expr);
 140         case EXPR_PREOP:
 141                 if (expr->op == '&')
 142                         return fake_pointer_sym(expr);
 143                 if (expr->op == '*')
 144                         return get_pointer_type(expr->unop);
 145                 return get_type(expr->unop);
 146         case EXPR_ASSIGNMENT:
 147                 return get_type(expr->left);
 148         case EXPR_CAST:
 149         case EXPR_FORCE_CAST:
 150         case EXPR_IMPLIED_CAST:
 151                 return get_real_base_type(expr->cast_type);
 152         case EXPR_BINOP:
 153                 return get_binop_type(expr);
 154         case EXPR_CALL:
 155                 return get_return_type(expr);
 156         case EXPR_SIZEOF:
 157                 return &ulong_ctype;
 158         case EXPR_COMPARE:
 159         case EXPR_LOGICAL:
 160                 return &int_ctype;
 161         default:
 162                 return expr->ctype;
 163 //              sm_msg("unhandled type %d", expr->type);
 164         }
 165
 166
 167         return NULL;
 168 }
 169
 170 int type_unsigned(struct symbol *base_type)
 171 {
 172         if (!base_type)
 173                 return 0;
 174         if (base_type->ctype.modifiers & MOD_UNSIGNED)
 175                 return 1;
 176         return 0;
 177 }
 178
 179 int expr_unsigned(struct expression *expr)
 180 {
 181         struct symbol *sym;
 182
 183         sym = get_type(expr);
 184         if (!sym)
 185                 return 0;
 186         if (type_unsigned(sym))
 187                 return 1;
 188         return 0;
 189 }
 190
 191 int returns_unsigned(struct symbol *sym)
 192 {
 193         if (!sym)
 194                 return 0;
 195         sym = get_base_type(sym);
 196         if (!sym || sym->type != SYM_FN)
 197                 return 0;
 198         sym = get_base_type(sym);
 199         return type_unsigned(sym);
 200 }
 201
 202 int is_pointer(struct expression *expr)
 203 {
 204         struct symbol *sym;
 205
 206         sym = get_type(expr);
 207         if (!sym)
 208                 return 0;
 209         if (sym->type == SYM_PTR)
 210                 return 1;
 211         return 0;
 212 }
 213
 214 int returns_pointer(struct symbol *sym)
 215 {
 216         if (!sym)
 217                 return 0;
 218         sym = get_base_type(sym);
 219         if (!sym || sym->type != SYM_FN)
 220                 return 0;
 221         sym = get_base_type(sym);
 222         if (sym->type == SYM_PTR)
 223                 return 1;
 224         return 0;
 225 }
 226
 227 long long type_max(struct symbol *base_type)
 228 {
 229         long long ret = whole_range.max;
 230         int bits;
 231
 232         if (!base_type || !base_type->bit_size)
 233                 return ret;
 234         bits = base_type->bit_size;
 235         if (bits == 64)
 236                 return ret;
 237         if (!type_unsigned(base_type))
 238                 bits--;
 239         ret >>= (63 - bits);
 240         return ret;
 241 }
 242
 243 sval_t sval_type_max(struct symbol *base_type)
 244 {
 245         sval_t ret;
 246
 247         ret.value = (~0ULL) >> 1;
 248         ret.type = base_type;
 249
 250         if (!base_type || !base_type->bit_size)
 251                 return ret;
 252
 253         if (type_unsigned(base_type))
 254                 ret.value = (~0ULL) >> (64 - base_type->bit_size);
 255         else
 256                 ret.value = (~0ULL) >> (64 - (base_type->bit_size - 1));
 257
 258         return ret;
 259 }
 260
 261 long long type_min(struct symbol *base_type)
 262 {
 263         long long ret = whole_range.min;
 264         int bits;
 265
 266         if (!base_type || !base_type->bit_size)
 267                 return ret;
 268         if (type_unsigned(base_type))
 269                 return 0;
 270         ret = whole_range.max;
 271         bits = base_type->bit_size - 1;
 272         ret >>= (63 - bits);
 273         return -(ret + 1);
 274 }
 275
 276 sval_t sval_type_min(struct symbol *base_type)
 277 {
 278         sval_t ret;
 279
 280         if (!base_type || !base_type->bit_size)
 281                 base_type = &llong_ctype;
 282         ret.type = base_type;
 283
 284         if (type_unsigned(base_type)) {
 285                 ret.value = 0;
 286                 return ret;
 287         }
 288
 289         ret.value = (~0ULL) << (base_type->bit_size - 1);
 290
 291         return ret;
 292 }
 293
 294 int nr_bits(struct expression *expr)
 295 {
 296         struct symbol *type;
 297
 298         type = get_type(expr);
 299         if (!type)
 300                 return 0;
 301         return type->bit_size;
 302 }
 303
 304 int is_static(struct expression *expr)
 305 {
 306         char *name;
 307         struct symbol *sym;
 308         int ret = 0;
 309
 310         name = get_variable_from_expr_complex(expr, &sym);
 311         if (!name || !sym)
 312                 goto free;
 313
 314         if (sym->ctype.modifiers & MOD_STATIC)
 315                 ret = 1;
 316 free:
 317         free_string(name);
 318         return ret;
 319 }
 320
 321 const char *global_static()
 322 {
 323         if (cur_func_sym->ctype.modifiers & MOD_STATIC)
 324                 return "static";
 325         else
 326                 return "global";
 327 }