4 * Copyright (C) 2010 Dan Carpenter.
6 * Licensed under the Open Software License version 1.1
12 #include "smatch_slist.h"
13 #include "smatch_extra.h"
15 static struct range_list
*_get_rl(struct expression
*expr
, int implied
);
16 static sval_t
_get_value(struct expression
*expr
, int *undefined
, int implied
);
17 static sval_t
_get_implied_value(struct expression
*expr
, int *undefined
, int implied
);
21 static sval_t zero
= {.type
= &int_ctype
, {.value
= 0} };
22 static sval_t one
= {.type
= &int_ctype
, {.value
= 1} };
23 static sval_t bogus
= {.type
= &int_ctype
, {.value
= BOGUS
} };
25 static struct range_list
*rl_zero(void)
27 return alloc_rl(zero
, zero
);
30 static struct range_list
*rl_one(void)
32 return alloc_rl(one
, one
);
55 static int implied_to_rl_enum(int implied
)
76 static int opposite_implied(int implied
)
78 if (implied
== IMPLIED_MIN
)
80 if (implied
== IMPLIED_MAX
)
82 if (implied
== FUZZY_MIN
)
84 if (implied
== FUZZY_MAX
)
86 if (implied
== ABSOLUTE_MIN
)
88 if (implied
== ABSOLUTE_MAX
)
90 if (implied
== HARD_MAX
) /* we don't have a hard min. */
96 static int last_stmt_sval(struct statement
*stmt
, sval_t
*sval
)
98 struct expression
*expr
;
103 stmt
= last_ptr_list((struct ptr_list
*)stmt
->stmts
);
104 if (stmt
->type
!= STMT_EXPRESSION
)
106 expr
= stmt
->expression
;
107 if (!get_value(expr
, sval
))
112 static sval_t
handle_expression_statement(struct expression
*expr
, int *undefined
, int implied
)
114 struct statement
*stmt
;
117 stmt
= get_expression_statement(expr
);
118 if (!last_stmt_sval(stmt
, &ret
)) {
126 static sval_t
handle_ampersand(int *undefined
, int implied
)
130 ret
.type
= &ptr_ctype
;
133 if (implied
== IMPLIED_MIN
|| implied
== FUZZY_MIN
|| implied
== ABSOLUTE_MIN
)
134 return valid_ptr_min_sval
;
135 if (implied
== IMPLIED_MAX
|| implied
== FUZZY_MAX
|| implied
== ABSOLUTE_MAX
)
136 return valid_ptr_max_sval
;
142 static sval_t
handle_negate(struct expression
*expr
, int *undefined
, int implied
)
146 ret
= sval_blank(expr
->unop
);
148 if (known_condition_true(expr
->unop
)) {
153 if (implied
== EXACT
) {
158 if (implied_condition_true(expr
->unop
)) {
162 if (implied_condition_false(expr
->unop
)) {
166 if (implied
== IMPLIED_MIN
|| implied
== FUZZY_MIN
|| implied
== ABSOLUTE_MIN
) {
170 if (implied
== IMPLIED_MAX
|| implied
== FUZZY_MAX
|| implied
== ABSOLUTE_MAX
) {
178 static struct range_list
*handle_preop_rl(struct expression
*expr
, int implied
)
185 ret
= handle_ampersand(&undefined
, implied
);
188 ret
= handle_negate(expr
, &undefined
, implied
);
191 ret
= _get_value(expr
->unop
, &undefined
, implied
);
192 ret
= sval_preop(ret
, '~');
193 ret
= sval_cast(get_type(expr
->unop
), ret
);
196 ret
= _get_value(expr
->unop
, &undefined
, implied
);
197 ret
= sval_preop(ret
, '-');
200 ret
= _get_implied_value(expr
, &undefined
, implied
);
203 ret
= handle_expression_statement(expr
, &undefined
, implied
);
210 ret
= sval_cast(get_type(expr
), ret
);
211 return alloc_rl(ret
, ret
);
214 static sval_t
handle_preop(struct expression
*expr
, int *undefined
, int implied
)
220 ret
= handle_ampersand(undefined
, implied
);
223 ret
= handle_negate(expr
, undefined
, implied
);
226 ret
= _get_value(expr
->unop
, undefined
, implied
);
227 ret
= sval_preop(ret
, '~');
228 ret
= sval_cast(get_type(expr
->unop
), ret
);
231 ret
= _get_value(expr
->unop
, undefined
, implied
);
232 ret
= sval_preop(ret
, '-');
235 ret
= _get_implied_value(expr
, undefined
, implied
);
238 ret
= handle_expression_statement(expr
, undefined
, implied
);
242 ret
= sval_blank(expr
);
244 ret
= sval_cast(get_type(expr
), ret
);
248 static sval_t
handle_divide(struct expression
*expr
, int *undefined
, int implied
)
252 left
= _get_value(expr
->left
, undefined
, implied
);
253 right
= _get_value(expr
->right
, undefined
, opposite_implied(implied
));
255 if (right
.value
== 0) {
260 return sval_binop(left
, '/', right
);
263 static sval_t
handle_subtract(struct expression
*expr
, int *undefined
, int implied
)
266 sval_t left
, right
, ret
;
267 int left_undefined
= 0;
268 int right_undefined
= 0;
269 int known_but_negative
= 0;
272 left
= _get_value(expr
->left
, &left_undefined
, implied
);
273 right
= _get_value(expr
->right
, &right_undefined
, opposite_implied(implied
));
275 if (!left_undefined
&& !right_undefined
) {
276 ret
= sval_binop(left
, '-', right
);
277 if (sval_is_negative(ret
))
278 known_but_negative
= 1;
280 return ret
; /* best case scenario */
283 comparison
= get_comparison(expr
->left
, expr
->right
);
287 type
= get_type(expr
);
289 switch (comparison
) {
291 case SPECIAL_UNSIGNED_GT
:
296 return sval_type_val(type
, 1);
300 return _get_value(expr
->left
, undefined
, implied
);
304 case SPECIAL_UNSIGNED_GTE
:
309 return sval_type_val(type
, 0);
313 return _get_value(expr
->left
, undefined
, implied
);
318 if (known_but_negative
)
326 static sval_t
handle_mod(struct expression
*expr
, int *undefined
, int implied
)
330 /* if we can't figure out the right side it's probably hopeless */
331 right
= _get_value(expr
->right
, undefined
, implied
);
332 if (*undefined
|| right
.value
== 0) {
340 left
= _get_value(expr
->left
, undefined
, implied
);
342 return sval_binop(left
, '%', right
);
348 return sval_type_val(get_type(expr
), 0);
353 right
= sval_cast(get_type(expr
), right
);
360 static sval_t
handle_binop(struct expression
*expr
, int *undefined
, int implied
)
364 sval_t ret
= {.type
= &int_ctype
, {.value
= 123456} };
369 return handle_mod(expr
, undefined
, implied
);
371 if (implied
== HARD_MAX
) {
375 left
= _get_value(expr
->left
, &local_undef
, implied
);
377 if (implied
== IMPLIED_MIN
|| implied
== ABSOLUTE_MIN
) {
378 ret
= sval_blank(expr
->left
);
382 if (implied
!= IMPLIED_MAX
&& implied
!= ABSOLUTE_MAX
)
384 if (!get_absolute_max(expr
->left
, &left
))
387 right
= _get_value(expr
->right
, undefined
, implied
);
390 return sval_binop(left
, '&', right
);
392 case SPECIAL_RIGHTSHIFT
:
393 if (implied
== HARD_MAX
) {
397 left
= _get_value(expr
->left
, &local_undef
, implied
);
399 if (implied
== IMPLIED_MIN
|| implied
== ABSOLUTE_MIN
) {
400 ret
= sval_blank(expr
->left
);
404 if (implied
!= IMPLIED_MAX
&& implied
!= ABSOLUTE_MAX
)
406 if (!get_absolute_max(expr
->left
, &left
))
409 right
= _get_value(expr
->right
, undefined
, implied
);
412 return sval_binop(left
, SPECIAL_RIGHTSHIFT
, right
);
414 return handle_subtract(expr
, undefined
, implied
);
417 left
= _get_value(expr
->left
, undefined
, implied
);
418 right
= _get_value(expr
->right
, undefined
, implied
);
423 type
= get_type(expr
);
424 left
= sval_cast(type
, left
);
425 right
= sval_cast(type
, right
);
430 if (sval_binop_overflows(left
, expr
->op
, right
))
431 return sval_type_max(get_type(expr
));
435 if (sval_binop_overflows(left
, expr
->op
, right
)) {
443 return handle_divide(expr
, undefined
, implied
);
445 if (right
.value
== 0) {
449 return sval_binop(left
, '%', right
);
452 ret
= sval_binop(left
, expr
->op
, right
);
457 static int do_comparison(struct expression
*expr
)
459 struct range_list
*left_ranges
= NULL
;
460 struct range_list
*right_ranges
= NULL
;
461 int poss_true
, poss_false
;
464 type
= get_type(expr
);
466 get_implied_rl(expr
->left
, &left_ranges
);
467 get_implied_rl(expr
->right
, &right_ranges
);
468 left_ranges
= cast_rl(type
, left_ranges
);
469 right_ranges
= cast_rl(type
, right_ranges
);
471 poss_true
= possibly_true_rl(left_ranges
, expr
->op
, right_ranges
);
472 poss_false
= possibly_false_rl(left_ranges
, expr
->op
, right_ranges
);
474 free_rl(&left_ranges
);
475 free_rl(&right_ranges
);
477 if (!poss_true
&& !poss_false
)
479 if (poss_true
&& !poss_false
)
481 if (!poss_true
&& poss_false
)
486 static struct range_list
*handle_comparison_rl(struct expression
*expr
, int implied
)
491 if (get_value(expr
->left
, &left
) && get_value(expr
->right
, &right
)) {
492 struct data_range tmp_left
, tmp_right
;
496 tmp_right
.min
= right
;
497 tmp_right
.max
= right
;
498 if (true_comparison_range(&tmp_left
, expr
->op
, &tmp_right
))
503 if (implied
== EXACT
)
506 res
= do_comparison(expr
);
512 return alloc_rl(zero
, one
);
515 static sval_t
handle_comparison(struct expression
*expr
, int *undefined
, int implied
)
520 if (get_value(expr
->left
, &left
) && get_value(expr
->right
, &right
)) {
521 struct data_range tmp_left
, tmp_right
;
525 tmp_right
.min
= right
;
526 tmp_right
.max
= right
;
527 if (true_comparison_range(&tmp_left
, expr
->op
, &tmp_right
))
532 if (implied
== EXACT
) {
537 res
= do_comparison(expr
);
543 if (implied
== IMPLIED_MIN
|| implied
== FUZZY_MIN
|| implied
== ABSOLUTE_MIN
)
545 if (implied
== IMPLIED_MAX
|| implied
== FUZZY_MAX
|| implied
== ABSOLUTE_MAX
)
552 static struct range_list
*handle_logical_rl(struct expression
*expr
, int implied
)
558 if (implied
== EXACT
) {
559 if (get_value(expr
->left
, &left
))
561 if (get_value(expr
->right
, &right
))
564 if (get_implied_value(expr
->left
, &left
))
566 if (get_implied_value(expr
->right
, &right
))
571 case SPECIAL_LOGICAL_OR
:
572 if (left_known
&& left
.value
)
574 if (right_known
&& right
.value
)
576 if (left_known
&& right_known
)
579 case SPECIAL_LOGICAL_AND
:
580 if (left_known
&& right_known
) {
581 if (left
.value
&& right
.value
)
590 if (implied
== EXACT
)
593 return alloc_rl(zero
, one
);
596 static sval_t
handle_logical(struct expression
*expr
, int *undefined
, int implied
)
602 if (implied
== EXACT
) {
603 if (get_value(expr
->left
, &left
))
605 if (get_value(expr
->right
, &right
))
608 if (get_implied_value(expr
->left
, &left
))
610 if (get_implied_value(expr
->right
, &right
))
615 case SPECIAL_LOGICAL_OR
:
616 if (left_known
&& left
.value
)
618 if (right_known
&& right
.value
)
620 if (left_known
&& right_known
)
623 case SPECIAL_LOGICAL_AND
:
624 if (left_known
&& right_known
) {
625 if (left
.value
&& right
.value
)
635 if (implied
== IMPLIED_MIN
|| implied
== FUZZY_MIN
|| implied
== ABSOLUTE_MIN
)
637 if (implied
== IMPLIED_MAX
|| implied
== FUZZY_MAX
|| implied
== ABSOLUTE_MAX
)
644 static struct range_list
*handle_conditional_rl(struct expression
*expr
, int implied
)
646 struct range_list
*true_rl
, *false_rl
;
648 if (known_condition_true(expr
->conditional
))
649 return _get_rl(expr
->cond_true
, implied
);
650 if (known_condition_false(expr
->conditional
))
651 return _get_rl(expr
->cond_false
, implied
);
653 if (implied
== EXACT
)
656 if (implied_condition_true(expr
->conditional
))
657 return _get_rl(expr
->cond_true
, implied
);
658 if (implied_condition_false(expr
->conditional
))
659 return _get_rl(expr
->cond_false
, implied
);
661 true_rl
= _get_rl(expr
->cond_true
, implied
);
664 false_rl
= _get_rl(expr
->cond_false
, implied
);
668 return rl_union(true_rl
, false_rl
);
671 static sval_t
handle_conditional(struct expression
*expr
, int *undefined
, int implied
)
673 if (known_condition_true(expr
->conditional
))
674 return _get_value(expr
->cond_true
, undefined
, implied
);
675 if (known_condition_false(expr
->conditional
))
676 return _get_value(expr
->cond_false
, undefined
, implied
);
678 if (implied
== EXACT
) {
683 if (implied_condition_true(expr
->conditional
))
684 return _get_value(expr
->cond_true
, undefined
, implied
);
685 if (implied_condition_false(expr
->conditional
))
686 return _get_value(expr
->cond_false
, undefined
, implied
);
692 static int get_local_value(struct expression
*expr
, sval_t
*sval
, int implied
)
701 return get_local_min_helper(expr
, sval
);
706 return get_local_max_helper(expr
, sval
);
711 static int get_implied_value_helper(struct expression
*expr
, sval_t
*sval
, int implied
)
713 struct smatch_state
*state
;
717 /* fixme: this should return the casted value */
719 expr
= strip_expr(expr
);
721 if (get_value(expr
, sval
))
724 name
= expr_to_var_sym(expr
, &sym
);
727 *sval
= sval_blank(expr
);
728 state
= get_state(SMATCH_EXTRA
, name
, sym
);
730 if (!state
|| !state
->data
)
731 return get_local_value(expr
, sval
, implied
);
732 if (implied
== IMPLIED
) {
733 if (estate_get_single_value(state
, sval
))
737 if (implied
== HARD_MAX
) {
738 if (estate_get_hard_max(state
, sval
))
742 if (implied
== IMPLIED_MAX
|| implied
== ABSOLUTE_MAX
) {
743 *sval
= estate_max(state
);
746 *sval
= estate_min(state
);
750 static int get_fuzzy_max_helper(struct expression
*expr
, sval_t
*max
)
753 struct sm_state
*tmp
;
756 if (get_hard_max(expr
, &sval
)) {
761 sm
= get_sm_state_expr(SMATCH_EXTRA
, expr
);
765 sval
= sval_type_min(estate_type(sm
->state
));
766 FOR_EACH_PTR(sm
->possible
, tmp
) {
769 new_min
= estate_min(tmp
->state
);
770 if (sval_cmp(new_min
, sval
) > 0)
772 } END_FOR_EACH_PTR(tmp
);
774 if (sval_is_min(sval
))
776 if (sval
.value
== sval_type_min(sval
.type
).value
+ 1) /* it's common to be on off */
779 *max
= sval_cast(get_type(expr
), sval
);
783 static int get_fuzzy_min_helper(struct expression
*expr
, sval_t
*min
)
786 struct sm_state
*tmp
;
789 sm
= get_sm_state_expr(SMATCH_EXTRA
, expr
);
793 if (!sval_is_min(estate_min(sm
->state
))) {
794 *min
= estate_min(sm
->state
);
798 sval
= sval_type_max(estate_type(sm
->state
));
799 FOR_EACH_PTR(sm
->possible
, tmp
) {
802 new_max
= estate_max(tmp
->state
);
803 if (sval_cmp(new_max
, sval
) < 0)
805 } END_FOR_EACH_PTR(tmp
);
807 if (sval_is_max(sval
))
809 *min
= sval_cast(get_type(expr
), sval
);
813 static int get_const_value(struct expression
*expr
, sval_t
*sval
)
818 if (expr
->type
!= EXPR_SYMBOL
|| !expr
->symbol
)
821 if (!(sym
->ctype
.modifiers
& MOD_CONST
))
823 if (get_value(sym
->initializer
, &right
)) {
824 *sval
= sval_cast(get_type(expr
), right
);
830 static struct range_list
*handle_variable(struct expression
*expr
, int implied
)
832 struct smatch_state
*state
;
833 struct range_list
*rl
;
834 sval_t sval
, min
, max
;
836 if (get_const_value(expr
, &sval
))
837 return alloc_rl(sval
, sval
);
839 switch (implied_to_rl_enum(implied
)) {
845 state
= get_state_expr(SMATCH_EXTRA
, expr
);
846 if (!state
|| !state
->data
) {
847 if (get_local_rl(expr
, &rl
))
851 if (implied
== HARD_MAX
&& !estate_has_hard_max(state
))
853 return estate_rl(state
);
855 if (!get_fuzzy_min_helper(expr
, &min
))
856 min
= sval_type_min(get_type(expr
));
857 if (!get_fuzzy_max_helper(expr
, &max
))
859 return alloc_rl(min
, max
);
864 static sval_t
_get_implied_value(struct expression
*expr
, int *undefined
, int implied
)
868 ret
= sval_blank(expr
);
877 if (!get_implied_value_helper(expr
, &ret
, implied
))
881 if (!get_fuzzy_max_helper(expr
, &ret
))
885 if (!get_fuzzy_min_helper(expr
, &ret
))
894 static sval_t
handle_sizeof(struct expression
*expr
)
899 ret
= sval_blank(expr
);
900 sym
= expr
->cast_type
;
902 sym
= evaluate_expression(expr
->cast_expression
);
904 * Expressions of restricted types will possibly get
905 * promoted - check that here
907 if (is_restricted_type(sym
)) {
908 if (sym
->bit_size
< bits_in_int
)
910 } else if (is_fouled_type(sym
)) {
914 examine_symbol_type(sym
);
916 ret
.type
= size_t_ctype
;
917 if (sym
->bit_size
<= 0) /* sizeof(void) */ {
918 if (get_real_base_type(sym
) == &void_ctype
)
923 ret
.value
= bits_to_bytes(sym
->bit_size
);
928 static struct range_list
*handle_call_rl(struct expression
*expr
, int implied
)
930 struct range_list
*rl
;
932 if (implied
== EXACT
)
935 if (get_implied_return(expr
, &rl
))
937 return db_return_vals(expr
);
940 static sval_t
handle_call(struct expression
*expr
, int *undefined
, int implied
)
942 struct range_list
*rl
;
944 if (!get_implied_rl(expr
, &rl
)) {
951 if (sval_cmp(rl_min(rl
), rl_max(rl
)) == 0)
970 static struct range_list
*_get_rl(struct expression
*expr
, int implied
)
972 struct range_list
*rl
;
977 expr
= strip_parens(expr
);
980 type
= get_type(expr
);
983 switch (expr
->type
) {
985 sval
= sval_from_val(expr
, expr
->value
);
988 rl
= handle_preop_rl(expr
, implied
);
994 return _get_rl(expr
->unop
, implied
);
996 case EXPR_FORCE_CAST
:
997 case EXPR_IMPLIED_CAST
:
998 rl
= _get_rl(expr
->cast_expression
, implied
);
1002 return cast_rl(type
, rl
);
1005 sval
= handle_binop(expr
, &undefined
, implied
);
1008 rl
= handle_comparison_rl(expr
, implied
);
1014 rl
= handle_logical_rl(expr
, implied
);
1019 case EXPR_PTRSIZEOF
:
1021 sval
= handle_sizeof(expr
);
1024 case EXPR_CONDITIONAL
:
1025 rl
= handle_conditional_rl(expr
, implied
);
1031 rl
= handle_call_rl(expr
, implied
);
1038 rl
= handle_variable(expr
, implied
);
1045 if (undefined
&& type
&&
1046 (implied
== ABSOLUTE_MAX
|| implied
== ABSOLUTE_MIN
))
1047 return alloc_whole_rl(type
);
1050 rl
= alloc_rl(sval
, sval
);
1054 static sval_t
_get_value(struct expression
*expr
, int *undefined
, int implied
)
1056 struct symbol
*type
;
1066 expr
= strip_parens(expr
);
1067 type
= get_type(expr
);
1069 switch (expr
->type
) {
1071 ret
= sval_from_val(expr
, expr
->value
);
1074 ret
= handle_preop(expr
, undefined
, implied
);
1077 ret
= _get_value(expr
->unop
, undefined
, implied
);
1080 case EXPR_FORCE_CAST
:
1081 case EXPR_IMPLIED_CAST
:
1082 ret
= _get_value(expr
->cast_expression
, undefined
, implied
);
1083 ret
= sval_cast(type
, ret
);
1086 ret
= handle_binop(expr
, undefined
, implied
);
1089 ret
= handle_comparison(expr
, undefined
, implied
);
1092 ret
= handle_logical(expr
, undefined
, implied
);
1094 case EXPR_PTRSIZEOF
:
1096 ret
= handle_sizeof(expr
);
1099 if (get_const_value(expr
, &ret
)) {
1102 ret
= _get_implied_value(expr
, undefined
, implied
);
1105 case EXPR_CONDITIONAL
:
1106 ret
= handle_conditional(expr
, undefined
, implied
);
1109 ret
= handle_call(expr
, undefined
, implied
);
1112 ret
= _get_implied_value(expr
, undefined
, implied
);
1120 /* returns 1 if it can get a value literal or else returns 0 */
1121 int get_value(struct expression
*expr
, sval_t
*sval
)
1123 struct range_list
*rl
;
1125 rl
= _get_rl(expr
, EXACT
);
1126 if (!rl_to_sval(rl
, sval
))
1131 int get_implied_value(struct expression
*expr
, sval_t
*sval
)
1133 struct range_list
*rl
;
1135 rl
= _get_rl(expr
, IMPLIED
);
1136 if (!rl_to_sval(rl
, sval
))
1141 int get_implied_min(struct expression
*expr
, sval_t
*sval
)
1143 struct range_list
*rl
;
1145 rl
= _get_rl(expr
, IMPLIED_MIN
);
1152 int get_implied_max(struct expression
*expr
, sval_t
*sval
)
1154 struct range_list
*rl
;
1156 rl
= _get_rl(expr
, IMPLIED_MAX
);
1163 int get_implied_rl(struct expression
*expr
, struct range_list
**rl
)
1166 struct smatch_state
*state
;
1173 expr
= strip_parens(expr
);
1177 state
= get_state_expr(SMATCH_EXTRA
, expr
);
1179 *rl
= clone_rl(estate_rl(state
));
1183 if (expr
->type
== EXPR_CALL
) {
1184 if (get_implied_return(expr
, rl
))
1186 *rl
= db_return_vals(expr
);
1192 if (get_implied_value(expr
, &sval
)) {
1193 add_range(rl
, sval
, sval
);
1197 if (get_local_rl(expr
, rl
))
1200 min_known
= get_implied_min(expr
, &min
);
1201 max_known
= get_implied_max(expr
, &max
);
1202 if (!min_known
&& !max_known
)
1205 get_absolute_min(expr
, &min
);
1207 get_absolute_max(expr
, &max
);
1209 *rl
= alloc_rl(min
, max
);
1213 int get_hard_max(struct expression
*expr
, sval_t
*sval
)
1215 struct range_list
*rl
;
1217 rl
= _get_rl(expr
, HARD_MAX
);
1224 int get_fuzzy_min(struct expression
*expr
, sval_t
*sval
)
1226 struct range_list
*rl
;
1228 rl
= _get_rl(expr
, FUZZY_MIN
);
1235 int get_fuzzy_max(struct expression
*expr
, sval_t
*sval
)
1237 struct range_list
*rl
;
1240 rl
= _get_rl(expr
, FUZZY_MAX
);
1244 if (max
.uvalue
> INT_MAX
- 10000)
1250 int get_absolute_min(struct expression
*expr
, sval_t
*sval
)
1252 struct range_list
*rl
;
1253 struct symbol
*type
;
1255 type
= get_type(expr
);
1257 type
= &llong_ctype
; // FIXME: this is wrong but places assume get type can't fail.
1258 rl
= _get_rl(expr
, ABSOLUTE_MIN
);
1262 *sval
= sval_type_min(type
);
1264 if (sval_cmp(*sval
, sval_type_min(type
)) < 0)
1265 *sval
= sval_type_min(type
);
1269 int get_absolute_max(struct expression
*expr
, sval_t
*sval
)
1271 struct range_list
*rl
;
1272 struct symbol
*type
;
1274 type
= get_type(expr
);
1276 type
= &llong_ctype
;
1277 rl
= _get_rl(expr
, ABSOLUTE_MAX
);
1281 *sval
= sval_type_max(type
);
1283 if (sval_cmp(sval_type_max(type
), *sval
) < 0)
1284 *sval
= sval_type_max(type
);
1288 int known_condition_true(struct expression
*expr
)
1295 if (get_value(expr
, &tmp
) && tmp
.value
)
1301 int known_condition_false(struct expression
*expr
)
1309 if (expr
->type
== EXPR_CALL
) {
1310 if (sym_name_is("__builtin_constant_p", expr
->fn
))
1316 int implied_condition_true(struct expression
*expr
)
1323 if (known_condition_true(expr
))
1325 if (get_implied_value(expr
, &tmp
) && tmp
.value
)
1328 if (expr
->type
== EXPR_POSTOP
)
1329 return implied_condition_true(expr
->unop
);
1331 if (expr
->type
== EXPR_PREOP
&& expr
->op
== SPECIAL_DECREMENT
)
1332 return implied_not_equal(expr
->unop
, 1);
1333 if (expr
->type
== EXPR_PREOP
&& expr
->op
== SPECIAL_INCREMENT
)
1334 return implied_not_equal(expr
->unop
, -1);
1336 expr
= strip_expr(expr
);
1337 switch (expr
->type
) {
1339 if (do_comparison(expr
) == 1)
1343 if (expr
->op
== '!') {
1344 if (implied_condition_false(expr
->unop
))
1350 if (implied_not_equal(expr
, 0) == 1)
1357 int implied_condition_false(struct expression
*expr
)
1359 struct expression
*tmp
;
1365 if (known_condition_false(expr
))
1368 switch (expr
->type
) {
1370 if (do_comparison(expr
) == 2)
1373 if (expr
->op
== '!') {
1374 if (implied_condition_true(expr
->unop
))
1378 tmp
= strip_expr(expr
);
1380 return implied_condition_false(tmp
);
1383 if (get_implied_value(expr
, &sval
) && sval
.value
== 0)