math: remove some dead code
[smatch.git] / smatch_sval.c
blob8955220033c099c45444f2392330ca346c26b1b3
1 /*
2 * smatch/smatch_sval.c
4 * Copyright (C) 2012 Oracle.
6 * Licensed under the Open Software License version 1.1
9 * Basically the point of sval is that it can hold both ULLONG_MAX and
10 * LLONG_MIN. If it is an unsigned type then we use sval.uvalue or if it is
11 * signed we use sval.value.
13 * I considered just using one bit to store whether the value was signed vs
14 * unsigned but I think it might help to have the type information so we know
15 * how to do type promotion.
19 #include "smatch.h"
20 #include "smatch_slist.h"
21 #include "smatch_extra.h"
23 __ALLOCATOR(sval_t, "svals", sval);
25 sval_t *sval_alloc(sval_t sval)
27 sval_t *ret;
29 ret = __alloc_sval(0);
30 *ret = sval;
31 return ret;
34 sval_t *sval_alloc_permanent(sval_t sval)
36 sval_t *ret;
38 ret = malloc(sizeof(*ret));
39 *ret = sval;
40 return ret;
43 sval_t sval_blank(struct expression *expr)
45 sval_t ret;
47 ret.type = get_type(expr);
48 if (!ret.type)
49 ret.type = &llong_ctype;
50 ret.value = 123456789;
52 return ret;
55 sval_t sval_type_val(struct symbol *type, long long val)
57 sval_t ret;
59 ret.type = type;
60 ret.value = val;
61 return ret;
64 sval_t sval_from_val(struct expression *expr, long long val)
66 sval_t ret;
68 ret = sval_blank(expr);
69 ret.value = val;
70 ret = sval_cast(get_type(expr), ret);
72 return ret;
75 int sval_unsigned(sval_t sval)
77 return type_unsigned(sval.type);
80 int sval_signed(sval_t sval)
82 return !type_unsigned(sval.type);
85 int sval_bits(sval_t sval)
87 return type_bits(sval.type);
90 int sval_positive_bits(sval_t sval)
92 return type_positive_bits(sval.type);
95 int sval_bits_used(sval_t sval)
97 int i;
99 for (i = 64; i >= 1; i--) {
100 if (sval.uvalue & (1ULL << (i - 1)))
101 return i;
103 return 0;
106 int sval_is_negative(sval_t sval)
108 if (type_unsigned(sval.type))
109 return 0;
110 if (sval.value < 0)
111 return 1;
112 return 0;
115 int sval_is_positive(sval_t sval)
117 return !sval_is_negative(sval);
120 int sval_is_min(sval_t sval)
122 sval_t min = sval_type_min(sval.type);
124 if (sval_unsigned(sval)) {
125 if (sval.uvalue == 0)
126 return 1;
127 return 0;
129 /* return true for less than min as well */
130 return (sval.value <= min.value);
133 int sval_is_max(sval_t sval)
135 sval_t max = sval_type_max(sval.type);
137 if (sval_unsigned(sval))
138 return (sval.uvalue >= max.value);
139 return (sval.value >= max.value);
142 int sval_is_a_min(sval_t sval)
144 if (sval_signed(sval) && sval.value == SHRT_MIN)
145 return 1;
146 if (sval_signed(sval) && sval.value == INT_MIN)
147 return 1;
148 if (sval_signed(sval) && sval.value == LLONG_MIN)
149 return 1;
150 return 0;
153 int sval_is_a_max(sval_t sval)
155 if (sval.uvalue == SHRT_MAX)
156 return 1;
157 if (sval.uvalue == INT_MAX)
158 return 1;
159 if (sval.uvalue == LLONG_MAX)
160 return 1;
161 if (sval.uvalue == USHRT_MAX)
162 return 1;
163 if (sval.uvalue == UINT_MAX)
164 return 1;
165 if (sval_unsigned(sval) && sval.uvalue == ULLONG_MAX)
166 return 1;
167 return 0;
170 int sval_is_negative_min(sval_t sval)
172 if (!sval_is_negative(sval))
173 return 0;
174 return sval_is_min(sval);
178 * Returns -1 if one is smaller, 0 if they are the same and 1 if two is larger.
180 int sval_cmp(sval_t one, sval_t two)
182 struct symbol *type;
184 type = one.type;
185 if (sval_positive_bits(two) > sval_positive_bits(one))
186 type = two.type;
187 if (type_bits(type) < 31)
188 type = &int_ctype;
190 one = sval_cast(type, one);
191 two = sval_cast(type, two);
193 if (type_unsigned(type)) {
194 if (one.uvalue < two.uvalue)
195 return -1;
196 if (one.uvalue == two.uvalue)
197 return 0;
198 return 1;
200 /* fix me handle type promotion and unsigned values */
201 if (one.value < two.value)
202 return -1;
203 if (one.value == two.value)
204 return 0;
205 return 1;
208 int sval_cmp_t(struct symbol *type, sval_t one, sval_t two)
210 sval_t one_cast, two_cast;
212 one_cast = sval_cast(type, one);
213 two_cast = sval_cast(type, two);
214 return sval_cmp(one_cast, two_cast);
217 int sval_cmp_val(sval_t one, long long val)
219 sval_t sval;
221 sval = sval_type_val(&llong_ctype, val);
222 return sval_cmp(one, sval);
225 sval_t sval_min(sval_t one, sval_t two)
227 if (sval_cmp(one, two) > 0)
228 return two;
229 return one;
232 sval_t sval_max(sval_t one, sval_t two)
234 if (sval_cmp(one, two) < 0)
235 return two;
236 return one;
239 int sval_too_low(struct symbol *type, sval_t sval)
241 if (sval_is_negative(sval) && type_unsigned(type))
242 return 1;
243 if (type_signed(type) && sval_unsigned(sval))
244 return 0;
245 if (sval_cmp(sval, sval_type_min(type)) < 0)
246 return 1;
247 return 0;
250 int sval_too_high(struct symbol *type, sval_t sval)
252 if (sval_is_negative(sval))
253 return 0;
254 if (sval.uvalue > sval_type_max(type).uvalue)
255 return 1;
256 return 0;
259 int sval_fits(struct symbol *type, sval_t sval)
261 if (sval_too_low(type, sval))
262 return 0;
263 if (sval_too_high(type, sval))
264 return 0;
265 return 1;
268 sval_t sval_cast(struct symbol *type, sval_t sval)
270 sval_t ret;
272 if (!type)
273 type = &llong_ctype;
275 ret.type = type;
276 switch (sval_bits(ret)) {
277 case 8:
278 if (sval_unsigned(ret))
279 ret.value = (long long)(unsigned char)sval.value;
280 else
281 ret.value = (long long)(char)sval.value;
282 break;
283 case 16:
284 if (sval_unsigned(ret))
285 ret.value = (long long)(unsigned short)sval.value;
286 else
287 ret.value = (long long)(short)sval.value;
288 break;
289 case 32:
290 if (sval_unsigned(ret))
291 ret.value = (long long)(unsigned int)sval.value;
292 else
293 ret.value = (long long)(int)sval.value;
294 break;
295 default:
296 ret.value = sval.value;
298 return ret;
302 sval_t sval_preop(sval_t sval, int op)
304 switch (op) {
305 case '!':
306 sval.value = !sval.value;
307 break;
308 case '~':
309 sval.value = ~sval.value;
310 /* fixme: should probably cast this here */
311 break;
312 case '-':
313 sval.value = -sval.value;
314 break;
316 return sval;
319 static sval_t sval_binop_unsigned(struct symbol *type, sval_t left, int op, sval_t right)
321 sval_t ret;
323 ret.type = type;
324 switch (op) {
325 case '*':
326 ret.uvalue = left.uvalue * right.uvalue;
327 break;
328 case '/':
329 if (right.uvalue == 0) {
330 sm_msg("debug: %s: divide by zero", __func__);
331 ret.uvalue = 123456789;
332 } else {
333 ret.uvalue = left.uvalue / right.uvalue;
335 break;
336 case '+':
337 ret.uvalue = left.uvalue + right.uvalue;
338 break;
339 case '-':
340 ret.uvalue = left.uvalue - right.uvalue;
341 break;
342 case '%':
343 if (right.uvalue == 0) {
344 sm_msg("internal error: %s: MOD by zero", __func__);
345 ret.uvalue = 123456789;
346 } else {
347 ret.uvalue = left.uvalue % right.uvalue;
349 break;
350 case '|':
351 ret.uvalue = left.uvalue | right.uvalue;
352 break;
353 case '&':
354 ret.uvalue = left.uvalue & right.uvalue;
355 break;
356 case SPECIAL_RIGHTSHIFT:
357 ret.uvalue = left.uvalue >> right.uvalue;
358 break;
359 case SPECIAL_LEFTSHIFT:
360 ret.uvalue = left.uvalue << right.uvalue;
361 break;
362 case '^':
363 ret.uvalue = left.uvalue ^ right.uvalue;
364 break;
365 default:
366 sm_msg("internal error: %s: unhandled binop %s", __func__,
367 show_special(op));
368 ret.uvalue = 1234567;
370 return ret;
374 static sval_t sval_binop_signed(struct symbol *type, sval_t left, int op, sval_t right)
376 sval_t ret;
378 ret.type = type;
379 switch (op) {
380 case '*':
381 ret.value = left.value * right.value;
382 break;
383 case '/':
384 if (right.value == 0) {
385 sm_msg("debug: %s: divide by zero", __func__);
386 ret.value = 123456789;
387 } else if (left.value == LLONG_MIN && right.value == -1) {
388 sm_msg("debug: %s: invalid divide LLONG_MIN/-1", __func__);
389 ret.value = 12345678;
390 } else {
391 ret.value = left.value / right.value;
393 break;
394 case '+':
395 ret.value = left.value + right.value;
396 break;
397 case '-':
398 ret.value = left.value - right.value;
399 break;
400 case '%':
401 if (right.value == 0) {
402 sm_msg("internal error: %s: MOD by zero", __func__);
403 ret.value = 123456789;
404 } else {
405 ret.value = left.value % right.value;
407 break;
408 case '|':
409 ret.value = left.value | right.value;
410 break;
411 case '&':
412 ret.value = left.value & right.value;
413 break;
414 case SPECIAL_RIGHTSHIFT:
415 ret.value = left.value >> right.value;
416 break;
417 case SPECIAL_LEFTSHIFT:
418 ret.value = left.value << right.value;
419 break;
420 case '^':
421 ret.value = left.value ^ right.value;
422 break;
423 default:
424 sm_msg("internal error: %s: unhandled binop %s", __func__,
425 show_special(op));
426 ret.value = 1234567;
428 return ret;
431 sval_t sval_binop(sval_t left, int op, sval_t right)
433 struct symbol *type;
434 sval_t ret;
436 type = left.type;
437 if (sval_positive_bits(right) > sval_positive_bits(left))
438 type = right.type;
439 if (type_positive_bits(type) < 31)
440 type = &int_ctype;
442 if (type_unsigned(type))
443 ret = sval_binop_unsigned(type, left, op, right);
444 else
445 ret = sval_binop_signed(type, left, op, right);
446 return ret;
449 int sval_binop_overflows(sval_t left, int op, sval_t right)
451 struct symbol *type;
452 sval_t max, min;
454 type = left.type;
455 if (type_positive_bits(right.type) > type_positive_bits(left.type))
456 type = right.type;
457 if (type_positive_bits(type) < 31)
458 return 0;
459 max = sval_type_max(type);
460 min = sval_type_min(type);
462 switch (op) {
463 case '+':
464 if (left.uvalue > max.uvalue - right.uvalue)
465 return 1;
466 return 0;
467 case '*':
468 return right.uvalue != 0 && left.uvalue > max.uvalue / right.uvalue;
469 case '-':
470 return sval_cmp(right, sval_binop(min, '+', left)) < 0;
472 return 0;
475 const char *sval_to_str(sval_t sval)
477 char buf[30];
479 if (sval_unsigned(sval) && sval.value == ULLONG_MAX)
480 return "u64max";
481 if (sval_unsigned(sval) && sval.value == UINT_MAX)
482 return "u32max";
483 if (sval_unsigned(sval) && sval.value == USHRT_MAX)
484 return "u16max";
486 if (sval_signed(sval) && sval.value == LLONG_MAX)
487 return "s64max";
488 if (sval_signed(sval) && sval.value == INT_MAX)
489 return "s32max";
490 if (sval_signed(sval) && sval.value == SHRT_MAX)
491 return "s16max";
493 if (sval_signed(sval) && sval.value == SHRT_MIN)
494 return "s16min";
495 if (sval_signed(sval) && sval.value == INT_MIN)
496 return "s32min";
497 if (sval_signed(sval) && sval.value == LLONG_MIN)
498 return "s64min";
500 if (sval_unsigned(sval))
501 snprintf(buf, sizeof(buf), "%llu", sval.value);
502 else if (sval.value < 0)
503 snprintf(buf, sizeof(buf), "(%lld)", sval.value);
504 else
505 snprintf(buf, sizeof(buf), "%lld", sval.value);
507 return alloc_sname(buf);
510 const char *sval_to_numstr(sval_t sval)
512 char buf[30];
514 if (sval_unsigned(sval))
515 snprintf(buf, sizeof(buf), "%llu", sval.value);
516 else if (sval.value < 0)
517 snprintf(buf, sizeof(buf), "(%lld)", sval.value);
518 else
519 snprintf(buf, sizeof(buf), "%lld", sval.value);
521 return alloc_sname(buf);
524 sval_t ll_to_sval(long long val)
526 sval_t ret;
528 ret.type = &llong_ctype;
529 ret.value = val;
530 return ret;
533 static void free_svals(struct symbol *sym)
535 if (__inline_fn)
536 return;
537 clear_sval_alloc();
540 void register_sval(int my_id)
542 add_hook(&free_svals, END_FUNC_HOOK);