1 /*
2 * Copyright (C) 2012 Oracle.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
16 */
17
18 /*
19 * Basically the point of sval is that it can hold both ULLONG_MAX and
20 * LLONG_MIN. If it is an unsigned type then we use sval.uvalue or if it is
21 * signed we use sval.value.
22 *
23 * I considered just using one bit to store whether the value was signed vs
24 * unsigned but I think it might help to have the type information so we know
25 * how to do type promotion.
26 *
27 */
28
29 #include "smatch.h"
30 #include "smatch_slist.h"
31 #include "smatch_extra.h"
32
33 __ALLOCATOR(sval_t, "svals", sval);
34
35 sval_t *sval_alloc(sval_t sval)
36 {
37 sval_t *ret;
38
39 ret = __alloc_sval(0);
40 *ret = sval;
41 return ret;
42 }
43
44 sval_t *sval_alloc_permanent(sval_t sval)
45 {
46 sval_t *ret;
47
48 ret = malloc(sizeof(*ret));
49 *ret = sval;
50 return ret;
51 }
52
53 sval_t sval_blank(struct expression *expr)
54 {
55 sval_t ret;
56
57 ret.type = get_type(expr);
58 if (!ret.type)
59 ret.type = &int_ctype;
60 ret.value = 123456789;
61
62 return ret;
63 }
64
65 sval_t sval_type_val(struct symbol *type, long long val)
66 {
67 sval_t ret;
68
69 if (!type)
70 type = &llong_ctype;
71
72 ret.type = type;
73 ret.value = val;
74 return ret;
75 }
76
77 sval_t sval_type_fval(struct symbol *type, long double fval)
78 {
79 sval_t ret;
80
81 ret.type = &ldouble_ctype;
82 ret.ldvalue = fval;
83 return sval_cast(type, ret);
84 }
85
86 sval_t sval_from_val(struct expression *expr, long long val)
87 {
88 sval_t ret;
89
90 ret = sval_blank(expr);
91 ret.value = val;
92 ret = sval_cast(get_type(expr), ret);
93
94 return ret;
95 }
96
97 sval_t sval_from_fval(struct expression *expr, long double fval)
98 {
99 sval_t ret;
100
101 ret.type = &ldouble_ctype;
102 ret.ldvalue = fval;
103 ret = sval_cast(get_type(expr), ret);
104
105 return ret;
106 }
107
108 int sval_is_ptr(sval_t sval)
109 {
110 if (!sval.type)
111 return 0;
112 return (sval.type->type == SYM_PTR || sval.type->type == SYM_ARRAY);
113 }
114
115 bool sval_is_fp(sval_t sval)
116 {
117 return type_is_fp(sval.type);
118 }
119
120 int sval_unsigned(sval_t sval)
121 {
122 if (is_ptr_type(sval.type))
123 return true;
124 return type_unsigned(sval.type);
125 }
126
127 int sval_signed(sval_t sval)
128 {
129 return !type_unsigned(sval.type);
130 }
131
132 int sval_bits(sval_t sval)
133 {
134 return type_bits(sval.type);
135 }
136
137 int sval_bits_used(sval_t sval)
138 {
139 int i;
140
141 for (i = 64; i >= 1; i--) {
142 if (sval.uvalue & (1ULL << (i - 1)))
143 return i;
144 }
145 return 0;
146 }
147
148 int sval_is_negative(sval_t sval)
149 {
150 if (type_unsigned(sval.type))
151 return 0;
152 if (sval.value < 0)
153 return 1;
154 return 0;
155 }
156
157 int sval_is_positive(sval_t sval)
158 {
159 return !sval_is_negative(sval);
160 }
161
162 static bool fp_is_min(sval_t sval)
163 {
164 if (sval.type == &float_ctype)
165 return sval.fvalue == -FLT_MAX;
166 if (sval.type == &double_ctype)
167 return sval.dvalue == -DBL_MAX;
168 if (sval.type == &ldouble_ctype)
169 return sval.ldvalue == -LDBL_MAX;
170 sm_perror("%s: bad type: '%s'", __func__, type_to_str(sval.type));
171 return false;
172 }
173
174 int sval_is_min(sval_t sval)
175 {
176 sval_t min = sval_type_min(sval.type);
177
178 if (sval_is_fp(sval))
179 return fp_is_min(sval);
180
181 if (sval_unsigned(sval)) {
182 if (sval.uvalue == 0)
183 return 1;
184 return 0;
185 }
186 /* return true for less than min as well */
187 return (sval.value <= min.value);
188 }
189
190 static bool fp_is_max(sval_t sval)
191 {
192 if (sval.type == &float_ctype)
193 return sval.fvalue == FLT_MAX;
194 if (sval.type == &double_ctype)
195 return sval.dvalue == DBL_MAX;
196 if (sval.type == &ldouble_ctype)
197 return sval.ldvalue == LDBL_MAX;
198 sm_perror("%s: bad type: '%s'", __func__, type_to_str(sval.type));
199 return false;
200 }
201
202 int sval_is_max(sval_t sval)
203 {
204 sval_t max = sval_type_max(sval.type);
205
206 if (sval_is_fp(sval))
207 return fp_is_max(sval);
208
209 if (sval_unsigned(sval))
210 return (sval.uvalue >= max.value);
211 return (sval.value >= max.value);
212 }
213
214 int sval_is_a_min(sval_t sval)
215 {
216 if (sval_is_min(sval))
217 return 1;
218
219 if (sval_is_fp(sval))
220 return 0;
221
222 if (sval_signed(sval) && sval.value == SHRT_MIN)
223 return 1;
224 if (sval_signed(sval) && sval.value == INT_MIN)
225 return 1;
226 if (sval_signed(sval) && sval.value == LLONG_MIN)
227 return 1;
228 return 0;
229 }
230
231 int sval_is_a_max(sval_t sval)
232 {
233 if (sval_is_max(sval))
234 return 1;
235
236 if (sval_is_fp(sval))
237 return 0;
238
239 if (sval.uvalue == SHRT_MAX)
240 return 1;
241 if (sval.uvalue == INT_MAX)
242 return 1;
243 if (sval.uvalue == LLONG_MAX)
244 return 1;
245 if (sval.uvalue == USHRT_MAX)
246 return 1;
247 if (sval.uvalue == UINT_MAX)
248 return 1;
249 if (sval_unsigned(sval) && sval.uvalue == ULLONG_MAX)
250 return 1;
251 if (sval.value > valid_ptr_max - 1000 &&
252 sval.value < valid_ptr_max + 1000)
253 return 1;
254 return 0;
255 }
256
257 int sval_is_negative_min(sval_t sval)
258 {
259 if (sval_is_fp(sval))
260 return 0;
261
262 if (!sval_is_negative(sval))
263 return 0;
264 return sval_is_min(sval);
265 }
266
267 int sval_cmp_t(struct symbol *type, sval_t one, sval_t two)
268 {
269 sval_t one_cast, two_cast;
270
271 one_cast = sval_cast(type, one);
272 two_cast = sval_cast(type, two);
273 return sval_cmp(one_cast, two_cast);
274 }
275
276 int sval_cmp_val(sval_t one, long long val)
277 {
278 sval_t sval;
279
280 sval = sval_type_val(&llong_ctype, val);
281 return sval_cmp(one, sval);
282 }
283
284 sval_t sval_min(sval_t one, sval_t two)
285 {
286 if (sval_cmp(one, two) > 0)
287 return two;
288 return one;
289 }
290
291 sval_t sval_max(sval_t one, sval_t two)
292 {
293 if (sval_cmp(one, two) < 0)
294 return two;
295 return one;
296 }
297
298 int sval_too_low(struct symbol *type, sval_t sval)
299 {
300 if (sval_is_negative(sval) && type_unsigned(type))
301 return 1;
302 if (type_signed(type) && sval_unsigned(sval))
303 return 0;
304 if (type_signed(sval.type) &&
305 sval.value < sval_type_min(type).value)
306 return 1;
307 if (sval_cmp(sval, sval_type_min(type)) < 0)
308 return 1;
309 return 0;
310 }
311
312 int sval_too_high(struct symbol *type, sval_t sval)
313 {
314 if (sval_is_negative(sval))
315 return 0;
316 if (sval.uvalue > sval_type_max(type).uvalue)
317 return 1;
318 return 0;
319 }
320
321 int sval_fits(struct symbol *type, sval_t sval)
322 {
323 /* everything fits into floating point */
324 if (type_is_fp(type))
325 return 1;
326 /* floating points don't fit into int */
327 if (type_is_fp(sval.type))
328 return 0;
329
330 if (sval_too_low(type, sval))
331 return 0;
332 if (sval_too_high(type, sval))
333 return 0;
334 return 1;
335 }
336
337 static sval_t cast_to_fp(struct symbol *type, sval_t sval)
338 {
339 sval_t ret = {};
340
341 ret.type = type;
342 if (type == &float_ctype) {
343 if (!sval_is_fp(sval)) {
344 if (sval_unsigned(sval))
345 ret.fvalue = sval.uvalue;
346 else
347 ret.fvalue = sval.value;
348 } else if (sval.type == &float_ctype)
349 ret.fvalue = sval.fvalue;
350 else if (sval.type == &double_ctype)
351 ret.fvalue = sval.dvalue;
352 else
353 ret.fvalue = sval.ldvalue;
354 } else if (type == &double_ctype) {
355 if (!sval_is_fp(sval)) {
356 if (sval_unsigned(sval))
357 ret.dvalue = sval.uvalue;
358 else
359 ret.dvalue = sval.value;
360 } else if (sval.type == &float_ctype)
361 ret.dvalue = sval.fvalue;
362 else if (sval.type == &double_ctype)
363 ret.dvalue = sval.dvalue;
364 else
365 ret.dvalue = sval.ldvalue;
366 } else if (type == &ldouble_ctype) {
367 if (!sval_is_fp(sval)) {
368 if (sval_unsigned(sval))
369 ret.ldvalue = (long double)sval.uvalue;
370 else
371 ret.ldvalue = (long double)sval.value;
372 } else if (sval.type == &float_ctype)
373 ret.ldvalue = sval.fvalue;
374 else if (sval.type == &double_ctype)
375 ret.ldvalue = sval.dvalue;
376 else
377 ret.ldvalue = sval.ldvalue;
378 } else {
379 sm_perror("%s: bad type: %s", __func__, type_to_str(type));
380 }
381
382 return ret;
383 }
384
385 static sval_t cast_from_fp(struct symbol *type, sval_t sval)
386 {
387 sval_t ret = {};
388
389 ret.type = &llong_ctype;
390 if (sval.type == &float_ctype)
391 ret.value = sval.fvalue;
392 else if (sval.type == &double_ctype)
393 ret.value = sval.dvalue;
394 else if (sval.type == &ldouble_ctype)
395 ret.value = sval.ldvalue;
396 else
397 sm_perror("%s: bad type: %s", __func__, type_to_str(type));
398
399 return sval_cast(type, ret);
400 }
401
402 sval_t sval_cast(struct symbol *type, sval_t sval)
403 {
404 sval_t ret;
405
406 if (!type)
407 type = &int_ctype;
408
409 if (type_is_fp(type))
410 return cast_to_fp(type, sval);
411 if (type_is_fp(sval.type))
412 return cast_from_fp(type, sval);
413
414 ret.type = type;
415 switch (sval_bits(ret)) {
416 case 1:
417 ret.value = !!sval.value;
418 break;
419 case 8:
420 if (sval_unsigned(ret))
421 ret.value = (long long)(unsigned char)sval.value;
422 else
423 ret.value = (long long)(char)sval.value;
424 break;
425 case 16:
426 if (sval_unsigned(ret))
427 ret.value = (long long)(unsigned short)sval.value;
428 else
429 ret.value = (long long)(short)sval.value;
430 break;
431 case 32:
432 if (sval_unsigned(ret))
433 ret.value = (long long)(unsigned int)sval.value;
434 else
435 ret.value = (long long)(int)sval.value;
436 break;
437 default:
438 ret.value = sval.value;
439 }
440 return ret;
441
442 }
443
444 sval_t sval_preop(sval_t sval, int op)
445 {
446 switch (op) {
447 case '!':
448 sval.value = !sval.value;
449 break;
450 case '~':
451 sval.value = ~sval.value;
452 sval = sval_cast(sval.type, sval);
453 break;
454 case '-':
455 sval.value = -sval.value;
456 sval = sval_cast(sval.type, sval);
457 break;
458 }
459 return sval;
460 }
461
462 static sval_t sval_binop_unsigned(struct symbol *type, sval_t left, int op, sval_t right)
463 {
464 sval_t ret;
465
466 ret.type = type;
467 switch (op) {
468 case '*':
469 ret.uvalue = left.uvalue * right.uvalue;
470 break;
471 case '/':
472 if (right.uvalue == 0) {
473 sm_debug("%s: divide by zero", __func__);
474 ret.uvalue = 123456789;
475 } else {
476 ret.uvalue = left.uvalue / right.uvalue;
477 }
478 break;
479 case '+':
480 ret.uvalue = left.uvalue + right.uvalue;
481 break;
482 case '-':
483 ret.uvalue = left.uvalue - right.uvalue;
484 break;
485 case '%':
486 if (right.uvalue == 0) {
487 sm_perror(" %s: MOD by zero", __func__);
488 ret.uvalue = 123456789;
489 } else {
490 ret.uvalue = left.uvalue % right.uvalue;
491 }
492 break;
493 case '|':
494 ret.uvalue = left.uvalue | right.uvalue;
495 break;
496 case '&':
497 ret.uvalue = left.uvalue & right.uvalue;
498 break;
499 case SPECIAL_RIGHTSHIFT:
500 ret.uvalue = left.uvalue >> right.uvalue;
501 break;
502 case SPECIAL_LEFTSHIFT:
503 ret.uvalue = left.uvalue << right.uvalue;
504 break;
505 case '^':
506 ret.uvalue = left.uvalue ^ right.uvalue;
507 break;
508 default:
509 sm_perror(" %s: unhandled binop %s", __func__,
510 show_special(op));
511 ret.uvalue = 1234567;
512 }
513 return ret;
514 }
515
516
517 static sval_t sval_binop_signed(struct symbol *type, sval_t left, int op, sval_t right)
518 {
519 sval_t ret;
520
521 ret.type = type;
522 switch (op) {
523 case '*':
524 ret.value = left.value * right.value;
525 break;
526 case '/':
527 if (right.value == 0) {
528 sm_debug("%s: divide by zero", __func__);
529 ret.value = 123456789;
530 } else if (left.value == LLONG_MIN && right.value == -1) {
531 sm_debug("%s: invalid divide LLONG_MIN/-1", __func__);
532 ret.value = 12345678;
533 } else {
534 ret.value = left.value / right.value;
535 }
536 break;
537 case '+':
538 ret.value = left.value + right.value;
539 break;
540 case '-':
541 ret.value = left.value - right.value;
542 break;
543 case '%':
544 if (right.value == 0) {
545 sm_perror(" %s: MOD by zero", __func__);
546 ret.value = 123456789;
547 } else {
548 ret.value = left.value % right.value;
549 }
550 break;
551 case '|':
552 ret.value = left.value | right.value;
553 break;
554 case '&':
555 ret.value = left.value & right.value;
556 break;
557 case SPECIAL_RIGHTSHIFT:
558 ret.value = left.value >> right.value;
559 break;
560 case SPECIAL_LEFTSHIFT:
561 ret.value = left.value << right.value;
562 break;
563 case '^':
564 ret.value = left.value ^ right.value;
565 break;
566 default:
567 sm_perror(" %s: unhandled binop %s", __func__,
568 show_special(op));
569 ret.value = 1234567;
570 }
571 return ret;
572 }
573
574 static sval_t ptr_binop(struct symbol *type, sval_t left, int op, sval_t right)
575 {
576 sval_t ret;
577 int align;
578
579 if (op != '+' && op != '-')
580 return sval_binop_unsigned(type, left, op, right);
581
582 ret.type = type;
583 if (type->type == SYM_PTR)
584 type = get_real_base_type(type);
585 align = type->ctype.alignment;
586 if (align <= 0)
587 align = 1;
588
589 if (op == '+') {
590 if (type_is_ptr(left.type))
591 ret.value = left.value + right.value * align;
592 else
593 ret.value = left.value * align + right.value;
594 } else {
595 if (!type_is_ptr(left.type)) {
596 left.value = -left.value;
597 ret = ptr_binop(type, left, '+', right);
598 } else if (!type_is_ptr(right.type)) {
599 right.value = -right.value;
600 ret = ptr_binop(type, left, '+', right);
601 } else {
602 ret.value = (left.value - right.value) / align;
603 }
604 }
605
606 if (op == '-')
607 ret.type = ssize_t_ctype;
608 return ret;
609 }
610
611 sval_t sval_binop(sval_t left, int op, sval_t right)
612 {
613 struct symbol *type;
614 sval_t ret;
615
616 type = get_promoted_type(left.type, right.type);
617
618 if (type_is_ptr(type))
619 ret = ptr_binop(type, left, op, right);
620 else if (type_unsigned(type))
621 ret = sval_binop_unsigned(type, left, op, right);
622 else
623 ret = sval_binop_signed(type, left, op, right);
624 return sval_cast(type, ret);
625 }
626
627 int sval_unop_overflows(sval_t sval, int op)
628 {
629 if (op != '-')
630 return 0;
631 if (sval_positive_bits(sval) == 32 && sval.value == INT_MIN)
632 return 1;
633 if (sval_positive_bits(sval) == 64 && sval.value == LLONG_MIN)
634 return 1;
635 if (sval_is_negative(sval))
636 return 0;
637 if (sval_signed(sval))
638 return 0;
639 if (sval_bits(sval) == 32 && sval.uvalue > INT_MAX)
640 return 1;
641 if (sval_bits(sval) == 64 && sval.uvalue > LLONG_MAX)
642 return 1;
643 return 0;
644 }
645
646 int sval_binop_overflows(sval_t left, int op, sval_t right)
647 {
648 struct symbol *type;
649 sval_t max, min;
650
651 type = left.type;
652 if (type_positive_bits(right.type) > type_positive_bits(left.type))
653 type = right.type;
654 if (type_positive_bits(type) < 31)
655 type = &int_ctype;
656
657 max = sval_type_max(type);
658 min = sval_type_min(type);
659
660 switch (op) {
661 case '+':
662 if (sval_is_negative(left) && sval_is_negative(right)) {
663 if (left.value < min.value + right.value)
664 return 1;
665 return 0;
666 }
667 if (sval_is_negative(left) || sval_is_negative(right))
668 return 0;
669 if (left.uvalue > max.uvalue - right.uvalue)
670 return 1;
671 return 0;
672 case '*':
673 if (type_signed(type)) {
674 if (left.value == 0 || right.value == 0)
675 return 0;
676 if (left.value > max.value / right.value)
677 return 1;
678 if (left.value == -1 || right.value == -1)
679 return 0;
680 return left.value != left.value * right.value / right.value;
681
682 }
683 return right.uvalue != 0 && left.uvalue > max.uvalue / right.uvalue;
684 case '-':
685 if (type_unsigned(type)) {
686 if (sval_cmp(left, right) < 0)
687 return 1;
688 return 0;
689 }
690 if (sval_is_negative(left) && sval_is_negative(right))
691 return 0;
692
693 if (sval_is_negative(left)) {
694 if (left.value < min.value + right.value)
695 return 1;
696 return 0;
697 }
698 if (sval_is_negative(right)) {
699 if (right.value == min.value)
700 return 1;
701 right = sval_preop(right, '-');
702 if (sval_binop_overflows(left, '+', right))
703 return 1;
704 return 0;
705 }
706 return 0;
707 case SPECIAL_LEFTSHIFT:
708 if (sval_cmp(left, sval_binop(max, invert_op(op), right)) > 0)
709 return 1;
710 return 0;
711 }
712 return 0;
713 }
714
715 int sval_binop_overflows_no_sign(sval_t left, int op, sval_t right)
716 {
717
718 struct symbol *type;
719
720 type = left.type;
721 if (type_positive_bits(right.type) > type_positive_bits(left.type))
722 type = right.type;
723 if (type_positive_bits(type) <= 31)
724 type = &uint_ctype;
725 else
726 type = &ullong_ctype;
727
728 left = sval_cast(type, left);
729 right = sval_cast(type, right);
730 return sval_binop_overflows(left, op, right);
731 }
732
733 int find_first_zero_bit(unsigned long long uvalue)
734 {
735 int i;
736
737 for (i = 0; i < 64; i++) {
738 if (!(uvalue & (1ULL << i)))
739 return i;
740 }
741 return i;
742 }
743
744 int sm_fls64(unsigned long long uvalue)
745 {
746 int high_bit = 0;
747
748 while (uvalue) {
749 uvalue >>= 1;
750 high_bit++;
751 }
752
753 return high_bit;
754 }
755
756 unsigned long long fls_mask(unsigned long long uvalue)
757 {
758 int high_bit = 0;
759
760 high_bit = sm_fls64(uvalue);
761 if (high_bit == 0)
762 return 0;
763
764 return ((unsigned long long)-1) >> (64 - high_bit);
765 }
766
767 unsigned long long sval_fls_mask(sval_t sval)
768 {
769 return fls_mask(sval.uvalue);
770 }
771
772 static char *fp_to_str(sval_t sval)
773 {
774 char buf[32];
775
776 if (sval.type == &float_ctype)
777 snprintf(buf, sizeof(buf), "%f", sval.fvalue);
778 else if (sval.type == &double_ctype)
779 snprintf(buf, sizeof(buf), "%e", sval.dvalue);
780 else if (sval.type == &ldouble_ctype) {
781 snprintf(buf, sizeof(buf), "%Lf", sval.ldvalue);
782 } else
783 snprintf(buf, sizeof(buf), "nan");
784
785 return alloc_sname(buf);
786 }
787
788 const char *sval_to_str(sval_t sval)
789 {
790 char buf[32];
791
792 if (sval_is_fp(sval))
793 return fp_to_str(sval);
794
795 if (sval_is_ptr(sval) && sval.value == valid_ptr_max)
796 return "ptr_max";
797 if (sval_unsigned(sval) && sval.value == ULLONG_MAX)
798 return "u64max";
799 if (sval_unsigned(sval) && sval.value == UINT_MAX)
800 return "u32max";
801 if (sval.value == USHRT_MAX)
802 return "u16max";
803
804 if (sval_signed(sval) && sval.value == LLONG_MAX)
805 return "s64max";
806 if (sval.value == INT_MAX)
807 return "s32max";
808 if (sval.value == SHRT_MAX)
809 return "s16max";
810
811 if (sval_signed(sval) && sval.value == SHRT_MIN)
812 return "s16min";
813 if (sval_signed(sval) && sval.value == INT_MIN)
814 return "s32min";
815 if (sval_signed(sval) && sval.value == LLONG_MIN)
816 return "s64min";
817
818 if (sval_unsigned(sval))
819 snprintf(buf, sizeof(buf), "%llu", sval.value);
820 else if (sval.value < 0)
821 snprintf(buf, sizeof(buf), "(%lld)", sval.value);
822 else
823 snprintf(buf, sizeof(buf), "%lld", sval.value);
824
825 return alloc_sname(buf);
826 }
827
828 const char *sval_to_str_or_err_ptr(sval_t sval)
829 {
830 char buf[12];
831
832 if (option_project != PROJ_KERNEL ||
833 !is_ptr_type(sval.type))
834 return sval_to_str(sval);
835
836 if (!sval_is_fp(sval) && sval.uvalue >= -4905ULL) {
837 snprintf(buf, sizeof(buf), "(%lld)", sval.value);
838 return alloc_sname(buf);
839 }
840
841 return sval_to_str(sval);
842 }
843
844 const char *sval_to_numstr(sval_t sval)
845 {
846 char buf[30];
847
848 if (type_is_fp(sval.type))
849 return fp_to_str(sval);
850
851 if (sval_unsigned(sval))
852 snprintf(buf, sizeof(buf), "%llu", sval.value);
853 else if (sval.value < 0)
854 snprintf(buf, sizeof(buf), "(%lld)", sval.value);
855 else
856 snprintf(buf, sizeof(buf), "%lld", sval.value);
857
858 return alloc_sname(buf);
859 }
860
861 sval_t ll_to_sval(long long val)
862 {
863 sval_t ret;
864
865 ret.type = &llong_ctype;
866 ret.value = val;
867 return ret;
868 }
869
870 static void free_svals(struct symbol *sym)
871 {
872 if (__inline_fn)
873 return;
874 clear_sval_alloc();
875 }
876
877 void register_sval(int my_id)
878 {
879 add_hook(&free_svals, AFTER_FUNC_HOOK);
880 }