2 * sparse/smatch_types.c
4 * Copyright (C) 2009 Dan Carpenter.
6 * Licensed under the Open Software License version 1.1
11 * The idea here is that you have an expression and you
12 * want to know what the type is for that.
17 struct symbol
*get_real_base_type(struct symbol
*sym
)
21 ret
= get_base_type(sym
);
22 if (ret
&& ret
->type
== SYM_RESTRICT
)
23 return get_real_base_type(ret
);
27 static struct symbol
*get_binop_type(struct expression
*expr
)
29 struct symbol
*left
, *right
;
31 left
= get_type(expr
->left
);
32 right
= get_type(expr
->right
);
37 if (left
->type
== SYM_PTR
|| left
->type
== SYM_ARRAY
)
39 if (right
->type
== SYM_PTR
|| right
->type
== SYM_ARRAY
)
42 if (expr
->op
== SPECIAL_LEFTSHIFT
||
43 expr
->op
== SPECIAL_RIGHTSHIFT
) {
44 if (type_max(left
) < type_max(&int_ctype
))
49 if (type_max(left
) < type_max(&int_ctype
) &&
50 type_max(right
) < type_max(&int_ctype
))
53 if (type_max(right
) > type_max(left
))
58 static struct symbol
*get_type_symbol(struct expression
*expr
)
60 if (!expr
|| expr
->type
!= EXPR_SYMBOL
|| !expr
->symbol
)
63 return get_real_base_type(expr
->symbol
);
66 static struct symbol
*get_symbol_from_deref(struct expression
*expr
)
69 struct symbol
*struct_sym
;
72 if (!expr
|| expr
->type
!= EXPR_DEREF
)
75 member
= expr
->member
;
76 struct_sym
= get_type(expr
->deref
);
78 // sm_msg("could not find struct type");
81 if (struct_sym
->type
== SYM_PTR
)
82 struct_sym
= get_real_base_type(struct_sym
);
83 FOR_EACH_PTR(struct_sym
->symbol_list
, tmp
) {
84 if (tmp
->ident
== member
)
85 return get_real_base_type(tmp
);
86 } END_FOR_EACH_PTR(tmp
);
90 static struct symbol
*get_return_type(struct expression
*expr
)
94 tmp
= get_type(expr
->fn
);
97 return get_real_base_type(tmp
);
100 struct symbol
*get_pointer_type(struct expression
*expr
)
104 sym
= get_type(expr
);
105 if (!sym
|| (sym
->type
!= SYM_PTR
&& sym
->type
!= SYM_ARRAY
))
107 return get_real_base_type(sym
);
110 static struct symbol
*fake_pointer_sym(struct expression
*expr
)
115 sym
= alloc_symbol(expr
->pos
, SYM_PTR
);
117 base
= get_type(expr
);
120 sym
->ctype
.base_type
= base
;
124 struct symbol
*get_type(struct expression
*expr
)
128 expr
= strip_parens(expr
);
130 switch (expr
->type
) {
132 return get_type_symbol(expr
);
134 return get_symbol_from_deref(expr
);
137 return fake_pointer_sym(expr
);
139 return get_pointer_type(expr
->unop
);
140 return get_type(expr
->unop
);
141 case EXPR_ASSIGNMENT
:
142 return get_type(expr
->left
);
144 case EXPR_FORCE_CAST
:
145 case EXPR_IMPLIED_CAST
:
146 return get_real_base_type(expr
->cast_type
);
148 return get_binop_type(expr
);
150 return get_return_type(expr
);
158 // sm_msg("unhandled type %d", expr->type);
165 int type_unsigned(struct symbol
*base_type
)
169 if (base_type
->ctype
.modifiers
& MOD_UNSIGNED
)
174 int expr_unsigned(struct expression
*expr
)
178 sym
= get_type(expr
);
181 if (type_unsigned(sym
))
186 int returns_unsigned(struct symbol
*sym
)
190 sym
= get_base_type(sym
);
191 if (!sym
|| sym
->type
!= SYM_FN
)
193 sym
= get_base_type(sym
);
194 return type_unsigned(sym
);
197 int is_pointer(struct expression
*expr
)
201 sym
= get_type(expr
);
204 if (sym
->type
== SYM_PTR
)
209 int returns_pointer(struct symbol
*sym
)
213 sym
= get_base_type(sym
);
214 if (!sym
|| sym
->type
!= SYM_FN
)
216 sym
= get_base_type(sym
);
217 if (sym
->type
== SYM_PTR
)
222 long long type_max(struct symbol
*base_type
)
224 long long ret
= whole_range
.max
;
227 if (!base_type
|| !base_type
->bit_size
)
229 bits
= base_type
->bit_size
;
232 if (!type_unsigned(base_type
))
238 sval_t
sval_type_max(struct symbol
*base_type
)
242 ret
.value
= (~0ULL) >> 1;
243 ret
.type
= base_type
;
245 if (!base_type
|| !base_type
->bit_size
)
248 if (type_unsigned(base_type
))
249 ret
.value
= (~0ULL) >> (64 - base_type
->bit_size
);
251 ret
.value
= (~0ULL) >> (64 - (base_type
->bit_size
- 1));
256 long long type_min(struct symbol
*base_type
)
258 long long ret
= whole_range
.min
;
261 if (!base_type
|| !base_type
->bit_size
)
263 if (type_unsigned(base_type
))
265 ret
= whole_range
.max
;
266 bits
= base_type
->bit_size
- 1;
271 int nr_bits(struct expression
*expr
)
275 type
= get_type(expr
);
278 return type
->bit_size
;
281 int is_static(struct expression
*expr
)
287 name
= get_variable_from_expr_complex(expr
, &sym
);
291 if (sym
->ctype
.modifiers
& MOD_STATIC
)
298 const char *global_static()
300 if (cur_func_sym
->ctype
.modifiers
& MOD_STATIC
)