2 * sparse/smatch_extra.c
4 * Copyright (C) 2008 Dan Carpenter.
6 * Licensed under the Open Software License version 1.1
11 * smatch_extra.c is supposed to track the value of every variable.
23 #include "smatch_slist.h"
24 #include "smatch_extra.h"
28 struct string_list
*__ignored_macros
= NULL
;
29 static int in_warn_on_macro()
31 struct statement
*stmt
;
35 stmt
= get_current_statement();
38 macro
= get_macro_name(stmt
->pos
);
42 FOR_EACH_PTR(__ignored_macros
, tmp
) {
43 if (!strcmp(tmp
, macro
))
45 } END_FOR_EACH_PTR(tmp
);
49 typedef void (mod_hook
)(const char *name
, struct symbol
*sym
, struct smatch_state
*state
);
50 DECLARE_PTR_LIST(void_fn_list
, mod_hook
*);
51 static struct void_fn_list
*extra_mod_hooks
;
52 void add_extra_mod_hook(mod_hook
*fn
)
54 mod_hook
**p
= malloc(sizeof(mod_hook
*));
56 add_ptr_list(&extra_mod_hooks
, p
);
59 void call_extra_mod_hooks(const char *name
, struct symbol
*sym
, struct smatch_state
*state
)
63 FOR_EACH_PTR(extra_mod_hooks
, fn
) {
64 (*fn
)(name
, sym
, state
);
65 } END_FOR_EACH_PTR(fn
);
68 struct sm_state
*set_extra_mod(const char *name
, struct symbol
*sym
, struct smatch_state
*state
)
70 if (in_warn_on_macro())
72 remove_from_equiv(name
, sym
);
73 call_extra_mod_hooks(name
, sym
, state
);
74 return set_state(SMATCH_EXTRA
, name
, sym
, state
);
77 struct sm_state
*set_extra_expr_mod(struct expression
*expr
, struct smatch_state
*state
)
81 struct sm_state
*ret
= NULL
;
83 expr
= strip_expr(expr
);
84 name
= expr_to_var_sym(expr
, &sym
);
87 ret
= set_extra_mod(name
, sym
, state
);
93 void set_extra_nomod(const char *name
, struct symbol
*sym
, struct smatch_state
*state
)
96 struct smatch_state
*orig_state
;
98 orig_state
= get_state(SMATCH_EXTRA
, name
, sym
);
100 if (!estate_related(orig_state
)) {
101 set_state(SMATCH_EXTRA
, name
, sym
, state
);
105 set_related(state
, estate_related(orig_state
));
106 FOR_EACH_PTR(estate_related(orig_state
), rel
) {
107 if (option_debug_related
)
108 sm_msg("updating related %s to %s", rel
->name
, state
->name
);
109 set_state(SMATCH_EXTRA
, rel
->name
, rel
->sym
, state
);
110 } END_FOR_EACH_PTR(rel
);
114 * This is for return_implies_state() hooks which modify a SMATCH_EXTRA state
116 void set_extra_expr_nomod(struct expression
*expr
, struct smatch_state
*state
)
121 name
= expr_to_var_sym(expr
, &sym
);
124 set_extra_nomod(name
, sym
, state
);
130 static void set_extra_true_false(const char *name
, struct symbol
*sym
,
131 struct smatch_state
*true_state
,
132 struct smatch_state
*false_state
)
134 struct relation
*rel
;
135 struct smatch_state
*orig_state
;
137 if (in_warn_on_macro())
140 orig_state
= get_state(SMATCH_EXTRA
, name
, sym
);
142 if (!estate_related(orig_state
)) {
143 set_true_false_states(SMATCH_EXTRA
, name
, sym
, true_state
, false_state
);
148 set_related(true_state
, estate_related(orig_state
));
150 set_related(false_state
, estate_related(orig_state
));
152 FOR_EACH_PTR(estate_related(orig_state
), rel
) {
153 set_true_false_states(SMATCH_EXTRA
, rel
->name
, rel
->sym
,
154 true_state
, false_state
);
155 } END_FOR_EACH_PTR(rel
);
158 static void set_extra_expr_true_false(struct expression
*expr
,
159 struct smatch_state
*true_state
,
160 struct smatch_state
*false_state
)
165 expr
= strip_expr(expr
);
166 name
= expr_to_var_sym(expr
, &sym
);
169 set_extra_true_false(name
, sym
, true_state
, false_state
);
174 static struct sm_state
*handle_canonical_while_count_down(struct statement
*loop
)
176 struct expression
*iter_var
;
177 struct expression
*condition
;
179 struct smatch_state
*estate
;
182 condition
= strip_expr(loop
->iterator_pre_condition
);
185 if (condition
->type
!= EXPR_PREOP
&& condition
->type
!= EXPR_POSTOP
)
187 if (condition
->op
!= SPECIAL_DECREMENT
)
190 iter_var
= condition
->unop
;
191 sm
= get_sm_state_expr(SMATCH_EXTRA
, iter_var
);
194 if (sval_cmp_val(estate_min(sm
->state
), 0) < 0)
196 start
= estate_max(sm
->state
);
197 if (sval_cmp_val(start
, 0) <= 0)
199 if (!sval_is_max(start
))
202 if (condition
->type
== EXPR_PREOP
) {
203 estate
= alloc_estate_range(sval_type_val(start
.type
, 1), start
);
204 if (estate_has_hard_max(sm
->state
))
205 estate_set_hard_max(estate
);
206 estate_copy_fuzzy_max(estate
, sm
->state
);
207 set_extra_expr_mod(iter_var
, estate
);
209 if (condition
->type
== EXPR_POSTOP
) {
210 estate
= alloc_estate_range(sval_type_val(start
.type
, 0), start
);
211 if (estate_has_hard_max(sm
->state
))
212 estate_set_hard_max(estate
);
213 estate_copy_fuzzy_max(estate
, sm
->state
);
214 set_extra_expr_mod(iter_var
, estate
);
216 return get_sm_state_expr(SMATCH_EXTRA
, iter_var
);
219 static struct sm_state
*handle_canonical_for_inc(struct expression
*iter_expr
,
220 struct expression
*condition
)
222 struct expression
*iter_var
;
224 struct smatch_state
*estate
;
225 sval_t start
, end
, max
;
227 iter_var
= iter_expr
->unop
;
228 sm
= get_sm_state_expr(SMATCH_EXTRA
, iter_var
);
231 if (!estate_get_single_value(sm
->state
, &start
))
233 if (get_implied_max(condition
->right
, &end
))
234 end
= sval_cast(get_type(iter_var
), end
);
236 end
= sval_type_max(get_type(iter_var
));
238 if (get_sm_state_expr(SMATCH_EXTRA
, condition
->left
) != sm
)
241 switch (condition
->op
) {
242 case SPECIAL_UNSIGNED_LT
:
243 case SPECIAL_NOTEQUAL
:
245 if (!sval_is_min(end
))
248 case SPECIAL_UNSIGNED_LTE
:
254 if (sval_cmp(end
, start
) < 0)
256 estate
= alloc_estate_range(start
, end
);
257 if (get_hard_max(condition
->right
, &max
)) {
258 estate_set_hard_max(estate
);
259 if (condition
->op
== '<' ||
260 condition
->op
== SPECIAL_UNSIGNED_LT
||
261 condition
->op
== SPECIAL_NOTEQUAL
)
263 estate_set_fuzzy_max(estate
, max
);
265 set_extra_expr_mod(iter_var
, estate
);
266 return get_sm_state_expr(SMATCH_EXTRA
, iter_var
);
269 static struct sm_state
*handle_canonical_for_dec(struct expression
*iter_expr
,
270 struct expression
*condition
)
272 struct expression
*iter_var
;
274 struct smatch_state
*estate
;
277 iter_var
= iter_expr
->unop
;
278 sm
= get_sm_state_expr(SMATCH_EXTRA
, iter_var
);
281 if (!estate_get_single_value(sm
->state
, &start
))
283 if (!get_implied_min(condition
->right
, &end
))
284 end
= sval_type_min(get_type(iter_var
));
285 if (get_sm_state_expr(SMATCH_EXTRA
, condition
->left
) != sm
)
288 switch (condition
->op
) {
289 case SPECIAL_NOTEQUAL
:
291 if (!sval_is_min(end
) && !sval_is_max(end
))
299 if (sval_cmp(end
, start
) > 0)
301 estate
= alloc_estate_range(end
, start
);
302 estate_set_hard_max(estate
);
303 estate_set_fuzzy_max(estate
, estate_get_fuzzy_max(estate
));
304 set_extra_expr_mod(iter_var
, estate
);
305 return get_sm_state_expr(SMATCH_EXTRA
, iter_var
);
308 static struct sm_state
*handle_canonical_for_loops(struct statement
*loop
)
310 struct expression
*iter_expr
;
311 struct expression
*condition
;
313 if (!loop
->iterator_post_statement
)
315 if (loop
->iterator_post_statement
->type
!= STMT_EXPRESSION
)
317 iter_expr
= loop
->iterator_post_statement
->expression
;
318 if (!loop
->iterator_pre_condition
)
320 if (loop
->iterator_pre_condition
->type
!= EXPR_COMPARE
)
322 condition
= loop
->iterator_pre_condition
;
324 if (iter_expr
->op
== SPECIAL_INCREMENT
)
325 return handle_canonical_for_inc(iter_expr
, condition
);
326 if (iter_expr
->op
== SPECIAL_DECREMENT
)
327 return handle_canonical_for_dec(iter_expr
, condition
);
331 struct sm_state
*__extra_handle_canonical_loops(struct statement
*loop
, struct state_list
**slist
)
333 struct sm_state
*ret
;
335 __push_fake_cur_slist();
336 if (!loop
->iterator_post_statement
)
337 ret
= handle_canonical_while_count_down(loop
);
339 ret
= handle_canonical_for_loops(loop
);
340 *slist
= __pop_fake_cur_slist();
344 int __iterator_unchanged(struct sm_state
*sm
)
348 if (get_sm_state(my_id
, sm
->name
, sm
->sym
) == sm
)
353 static void while_count_down_after(struct sm_state
*sm
, struct expression
*condition
)
357 /* paranoid checking. prolly not needed */
358 condition
= strip_expr(condition
);
361 if (condition
->type
!= EXPR_PREOP
&& condition
->type
!= EXPR_POSTOP
)
363 if (condition
->op
!= SPECIAL_DECREMENT
)
365 after_value
= estate_min(sm
->state
);
367 set_extra_mod(sm
->name
, sm
->sym
, alloc_estate_sval(after_value
));
370 void __extra_pre_loop_hook_after(struct sm_state
*sm
,
371 struct statement
*iterator
,
372 struct expression
*condition
)
374 struct expression
*iter_expr
;
376 struct smatch_state
*state
;
379 while_count_down_after(sm
, condition
);
383 iter_expr
= iterator
->expression
;
385 if (condition
->type
!= EXPR_COMPARE
)
387 if (iter_expr
->op
== SPECIAL_INCREMENT
) {
388 limit
= sval_binop(estate_max(sm
->state
), '+',
389 sval_type_val(estate_type(sm
->state
), 1));
391 limit
= sval_binop(estate_min(sm
->state
), '-',
392 sval_type_val(estate_type(sm
->state
), 1));
394 if (!estate_has_hard_max(sm
->state
) && !__has_breaks()) {
395 if (iter_expr
->op
== SPECIAL_INCREMENT
)
396 state
= alloc_estate_range(estate_min(sm
->state
), limit
);
398 state
= alloc_estate_range(limit
, estate_max(sm
->state
));
400 state
= alloc_estate_sval(limit
);
402 if (!estate_has_hard_max(sm
->state
)) {
403 estate_clear_hard_max(state
);
405 if (estate_has_fuzzy_max(sm
->state
)) {
406 sval_t hmax
= estate_get_fuzzy_max(sm
->state
);
407 sval_t max
= estate_max(sm
->state
);
409 if (sval_cmp(hmax
, max
) != 0)
410 estate_clear_fuzzy_max(state
);
411 } else if (!estate_has_fuzzy_max(sm
->state
)) {
412 estate_clear_fuzzy_max(state
);
415 set_extra_mod(sm
->name
, sm
->sym
, state
);
418 static struct state_list
*unmatched_slist
;
419 static struct smatch_state
*unmatched_state(struct sm_state
*sm
)
421 struct smatch_state
*state
;
423 if (unmatched_slist
) {
424 state
= get_state_slist(unmatched_slist
, SMATCH_EXTRA
, sm
->name
, sm
->sym
);
428 return alloc_estate_whole(estate_type(sm
->state
));
431 static void clear_the_pointed_at(struct expression
*expr
, struct state_list
*slist
)
435 struct sm_state
*tmp
;
437 name
= expr_to_var_sym(expr
, &sym
);
441 FOR_EACH_PTR(slist
, tmp
) {
442 if (tmp
->name
[0] != '*')
446 if (strcmp(tmp
->name
+ 1, name
) != 0)
448 set_extra_mod(tmp
->name
, tmp
->sym
, alloc_estate_whole(estate_type(tmp
->state
)));
449 } END_FOR_EACH_PTR(tmp
);
455 static void match_function_call(struct expression
*expr
)
457 struct expression
*arg
;
458 struct expression
*tmp
;
459 struct state_list
*slist
;
461 /* if we have the db this is handled in smatch_function_hooks.c */
464 if (inlinable(expr
->fn
))
467 slist
= get_all_states(SMATCH_EXTRA
);
469 FOR_EACH_PTR(expr
->args
, arg
) {
470 tmp
= strip_expr(arg
);
471 if (tmp
->type
== EXPR_PREOP
&& tmp
->op
== '&')
472 set_extra_expr_mod(tmp
->unop
, alloc_estate_whole(get_type(tmp
->unop
)));
474 clear_the_pointed_at(tmp
, slist
);
475 } END_FOR_EACH_PTR(arg
);
480 static int types_equiv_or_pointer(struct symbol
*one
, struct symbol
*two
)
484 if (one
->type
== SYM_PTR
&& two
->type
== SYM_PTR
)
486 return types_equiv(one
, two
);
489 static void match_vanilla_assign(struct expression
*left
, struct expression
*right
)
491 struct range_list
*rl
= NULL
;
492 struct symbol
*right_sym
;
493 struct symbol
*left_type
;
494 struct symbol
*right_type
;
495 char *right_name
= NULL
;
499 struct smatch_state
*state
;
501 name
= expr_to_var_sym(left
, &sym
);
505 left_type
= get_type(left
);
506 right_type
= get_type(right
);
508 right_name
= expr_to_var_sym(right
, &right_sym
);
509 if (right_name
&& right_sym
&&
510 types_equiv_or_pointer(left_type
, right_type
)) {
511 set_equiv(left
, right
);
515 if (get_implied_rl(right
, &rl
)) {
516 rl
= cast_rl(left_type
, rl
);
517 state
= alloc_estate_rl(rl
);
518 if (get_hard_max(right
, &max
)) {
519 estate_set_hard_max(state
);
520 estate_set_fuzzy_max(state
, max
);
523 rl
= alloc_whole_rl(right_type
);
524 rl
= cast_rl(left_type
, rl
);
525 state
= alloc_estate_rl(rl
);
527 set_extra_mod(name
, sym
, state
);
529 free_string(right_name
);
532 static int op_remove_assign(int op
)
535 case SPECIAL_ADD_ASSIGN
:
537 case SPECIAL_SUB_ASSIGN
:
539 case SPECIAL_MUL_ASSIGN
:
541 case SPECIAL_DIV_ASSIGN
:
543 case SPECIAL_MOD_ASSIGN
:
545 case SPECIAL_AND_ASSIGN
:
547 case SPECIAL_OR_ASSIGN
:
549 case SPECIAL_XOR_ASSIGN
:
551 case SPECIAL_SHL_ASSIGN
:
552 return SPECIAL_LEFTSHIFT
;
553 case SPECIAL_SHR_ASSIGN
:
554 return SPECIAL_RIGHTSHIFT
;
560 static void match_assign(struct expression
*expr
)
562 struct range_list
*rl
= NULL
;
563 struct expression
*left
;
564 struct expression
*right
;
565 struct expression
*binop_expr
;
566 struct symbol
*left_type
;
567 struct symbol
*right_type
;
570 sval_t left_min
, left_max
;
571 sval_t right_min
, right_max
;
572 sval_t res_min
, res_max
;
574 left
= strip_expr(expr
->left
);
576 right
= strip_expr(expr
->right
);
577 while (right
->type
== EXPR_ASSIGNMENT
&& right
->op
== '=')
578 right
= strip_expr(right
->left
);
580 if (is_condition(expr
->right
))
581 return; /* handled in smatch_condition.c */
582 if (expr
->op
== '=' && right
->type
== EXPR_CALL
)
583 return; /* handled in smatch_function_hooks.c */
584 if (expr
->op
== '=') {
585 match_vanilla_assign(left
, right
);
589 name
= expr_to_var_sym(left
, &sym
);
593 left_type
= get_type(left
);
594 right_type
= get_type(right
);
596 res_min
= sval_type_min(right_type
);
597 res_max
= sval_type_max(right_type
);
600 case SPECIAL_ADD_ASSIGN
:
601 get_absolute_max(left
, &left_max
);
602 get_absolute_max(right
, &right_max
);
603 if (sval_binop_overflows(left_max
, '+', right_max
))
605 if (get_implied_min(left
, &left_min
) &&
606 !sval_is_negative_min(left_min
) &&
607 get_implied_min(right
, &right_min
) &&
608 !sval_is_negative_min(right_min
)) {
609 res_min
= sval_binop(left_min
, '+', right_min
);
610 res_min
= sval_cast(right_type
, res_min
);
612 if (inside_loop()) /* we are assuming loops don't lead to wrapping */
614 res_max
= sval_binop(left_max
, '+', right_max
);
615 res_max
= sval_cast(right_type
, res_max
);
617 case SPECIAL_SUB_ASSIGN
:
618 if (get_implied_max(left
, &left_max
) &&
619 !sval_is_max(left_max
) &&
620 get_implied_min(right
, &right_min
) &&
621 !sval_is_min(right_min
)) {
622 res_max
= sval_binop(left_max
, '-', right_min
);
623 res_max
= sval_cast(right_type
, res_max
);
627 if (get_implied_min(left
, &left_min
) &&
628 !sval_is_min(left_min
) &&
629 get_implied_max(right
, &right_max
) &&
630 !sval_is_max(right_max
)) {
631 res_min
= sval_binop(left_min
, '-', right_max
);
632 res_min
= sval_cast(right_type
, res_min
);
635 case SPECIAL_AND_ASSIGN
:
636 case SPECIAL_MOD_ASSIGN
:
637 case SPECIAL_SHL_ASSIGN
:
638 case SPECIAL_SHR_ASSIGN
:
639 case SPECIAL_OR_ASSIGN
:
640 case SPECIAL_XOR_ASSIGN
:
641 case SPECIAL_MUL_ASSIGN
:
642 case SPECIAL_DIV_ASSIGN
:
643 binop_expr
= binop_expression(expr
->left
,
644 op_remove_assign(expr
->op
),
646 if (get_implied_rl(binop_expr
, &rl
)) {
647 rl
= cast_rl(left_type
, rl
);
648 set_extra_mod(name
, sym
, alloc_estate_rl(rl
));
653 rl
= cast_rl(left_type
, alloc_rl(res_min
, res_max
));
654 set_extra_mod(name
, sym
, alloc_estate_rl(rl
));
659 static struct smatch_state
*increment_state(struct smatch_state
*state
)
661 sval_t min
= estate_min(state
);
662 sval_t max
= estate_max(state
);
664 if (!estate_rl(state
))
668 max
= sval_type_max(max
.type
);
670 if (!sval_is_min(min
) && !sval_is_max(min
))
672 if (!sval_is_min(max
) && !sval_is_max(max
))
674 return alloc_estate_range(min
, max
);
677 static struct smatch_state
*decrement_state(struct smatch_state
*state
)
679 sval_t min
= estate_min(state
);
680 sval_t max
= estate_max(state
);
682 if (!estate_rl(state
))
686 min
= sval_type_min(min
.type
);
688 if (!sval_is_min(min
) && !sval_is_max(min
))
690 if (!sval_is_min(max
) && !sval_is_max(max
))
692 return alloc_estate_range(min
, max
);
695 static void unop_expr(struct expression
*expr
)
697 struct smatch_state
*state
;
699 if (expr
->smatch_flags
& Handled
)
703 case SPECIAL_INCREMENT
:
704 state
= get_state_expr(SMATCH_EXTRA
, expr
->unop
);
705 state
= increment_state(state
);
707 state
= alloc_estate_whole(get_type(expr
));
708 set_extra_expr_mod(expr
->unop
, state
);
710 case SPECIAL_DECREMENT
:
711 state
= get_state_expr(SMATCH_EXTRA
, expr
->unop
);
712 state
= decrement_state(state
);
714 state
= alloc_estate_whole(get_type(expr
));
715 set_extra_expr_mod(expr
->unop
, state
);
722 static void asm_expr(struct statement
*stmt
)
725 struct expression
*expr
;
729 FOR_EACH_PTR(stmt
->asm_outputs
, expr
) {
731 case 0: /* identifier */
732 case 1: /* constraint */
735 case 2: /* expression */
737 type
= get_type(strip_expr(expr
));
738 set_extra_expr_mod(expr
, alloc_estate_whole(type
));
741 } END_FOR_EACH_PTR(expr
);
744 static void delete_state_tracker(struct tracker
*t
)
746 remove_from_equiv(t
->name
, t
->sym
);
747 delete_state(t
->owner
, t
->name
, t
->sym
);
750 static void scoped_state_extra(const char *name
, struct symbol
*sym
)
754 t
= alloc_tracker(SMATCH_EXTRA
, name
, sym
);
755 add_scope_hook((scope_hook
*)&delete_state_tracker
, t
);
758 static void match_declarations(struct symbol
*sym
)
763 name
= sym
->ident
->name
;
764 if (!sym
->initializer
) {
765 set_state(SMATCH_EXTRA
, name
, sym
, alloc_estate_whole(get_real_base_type(sym
)));
766 scoped_state_extra(name
, sym
);
771 static void check_dereference(struct expression
*expr
)
773 if (outside_of_function())
775 set_extra_expr_nomod(expr
, alloc_estate_range(valid_ptr_min_sval
, valid_ptr_max_sval
));
778 static void match_dereferences(struct expression
*expr
)
780 if (expr
->type
!= EXPR_PREOP
)
782 check_dereference(expr
->unop
);
785 static void match_pointer_as_array(struct expression
*expr
)
789 check_dereference(expr
->unop
->left
);
792 static void set_param_dereferenced(struct expression
*arg
, char *unused
)
794 check_dereference(arg
);
797 static void match_function_def(struct symbol
*sym
)
801 FOR_EACH_PTR(sym
->ctype
.base_type
->arguments
, arg
) {
804 set_state(my_id
, arg
->ident
->name
, arg
, alloc_estate_whole(get_real_base_type(arg
)));
805 } END_FOR_EACH_PTR(arg
);
808 static sval_t
add_one(sval_t sval
)
814 static sval_t
sub_one(sval_t sval
)
820 static void handle_comparison(struct symbol
*type
, struct expression
*left
, int op
, struct expression
*right
)
822 struct range_list
*left_orig
;
823 struct range_list
*left_true
;
824 struct range_list
*left_false
;
825 struct range_list
*right_orig
;
826 struct range_list
*right_true
;
827 struct range_list
*right_false
;
828 struct smatch_state
*left_true_state
;
829 struct smatch_state
*left_false_state
;
830 struct smatch_state
*right_true_state
;
831 struct smatch_state
*right_false_state
;
832 sval_t min
, max
, dummy
, hard_max
;
834 int right_postop
= 0;
836 if (left
->op
== SPECIAL_INCREMENT
|| left
->op
== SPECIAL_DECREMENT
) {
837 if (left
->type
== EXPR_POSTOP
) {
838 left
->smatch_flags
|= Handled
;
839 left_postop
= left
->op
;
841 left
= strip_expr(left
->unop
);
843 while (left
->type
== EXPR_ASSIGNMENT
)
844 left
= strip_expr(left
->left
);
846 if (right
->op
== SPECIAL_INCREMENT
|| right
->op
== SPECIAL_DECREMENT
) {
847 if (right
->type
== EXPR_POSTOP
) {
848 right
->smatch_flags
|= Handled
;
849 right_postop
= right
->op
;
851 right
= strip_expr(right
->unop
);
854 if (get_implied_rl(left
, &left_orig
)) {
855 left_orig
= cast_rl(type
, left_orig
);
857 min
= sval_type_min(get_type(left
));
858 max
= sval_type_max(get_type(left
));
859 left_orig
= cast_rl(type
, alloc_rl(min
, max
));
862 if (get_implied_rl(right
, &right_orig
)) {
863 right_orig
= cast_rl(type
, right_orig
);
865 min
= sval_type_min(get_type(right
));
866 max
= sval_type_max(get_type(right
));
867 right_orig
= cast_rl(type
, alloc_rl(min
, max
));
869 min
= sval_type_min(type
);
870 max
= sval_type_max(type
);
872 left_true
= clone_rl(left_orig
);
873 left_false
= clone_rl(left_orig
);
874 right_true
= clone_rl(right_orig
);
875 right_false
= clone_rl(right_orig
);
879 case SPECIAL_UNSIGNED_LT
:
880 left_true
= remove_range(left_orig
, rl_max(right_orig
), max
);
881 if (!sval_is_min(rl_min(right_orig
))) {
882 left_false
= remove_range(left_orig
, min
, sub_one(rl_min(right_orig
)));
885 right_true
= remove_range(right_orig
, min
, rl_min(left_orig
));
886 if (!sval_is_max(rl_max(left_orig
)))
887 right_false
= remove_range(right_orig
, add_one(rl_max(left_orig
)), max
);
889 case SPECIAL_UNSIGNED_LTE
:
891 if (!sval_is_max(rl_max(right_orig
)))
892 left_true
= remove_range(left_orig
, add_one(rl_max(right_orig
)), max
);
893 left_false
= remove_range(left_orig
, min
, rl_min(right_orig
));
895 if (!sval_is_min(rl_min(left_orig
)))
896 right_true
= remove_range(right_orig
, min
, sub_one(rl_min(left_orig
)));
897 right_false
= remove_range(right_orig
, rl_max(left_orig
), max
);
899 if (sval_cmp(rl_min(left_orig
), rl_min(right_orig
)) == 0)
900 left_false
= remove_range(left_false
, rl_min(left_orig
), rl_min(left_orig
));
901 if (sval_cmp(rl_max(left_orig
), rl_max(right_orig
)) == 0)
902 right_false
= remove_range(right_false
, rl_max(left_orig
), rl_max(left_orig
));
905 if (!sval_is_max(rl_max(right_orig
))) {
906 left_true
= remove_range(left_true
, add_one(rl_max(right_orig
)), max
);
908 if (!sval_is_min(rl_min(right_orig
))) {
909 left_true
= remove_range(left_true
, min
, sub_one(rl_min(right_orig
)));
911 if (sval_cmp(rl_min(right_orig
), rl_max(right_orig
)) == 0)
912 left_false
= remove_range(left_orig
, rl_min(right_orig
), rl_min(right_orig
));
914 if (!sval_is_max(rl_max(left_orig
)))
915 right_true
= remove_range(right_true
, add_one(rl_max(left_orig
)), max
);
916 if (!sval_is_min(rl_min(left_orig
)))
917 right_true
= remove_range(right_true
, min
, sub_one(rl_min(left_orig
)));
918 if (sval_cmp(rl_min(left_orig
), rl_max(left_orig
)) == 0)
919 right_false
= remove_range(right_orig
, rl_min(left_orig
), rl_min(left_orig
));
921 case SPECIAL_UNSIGNED_GTE
:
923 if (!sval_is_min(rl_min(right_orig
)))
924 left_true
= remove_range(left_orig
, min
, sub_one(rl_min(right_orig
)));
925 left_false
= remove_range(left_orig
, rl_max(right_orig
), max
);
927 if (!sval_is_max(rl_max(left_orig
)))
928 right_true
= remove_range(right_orig
, add_one(rl_max(left_orig
)), max
);
929 right_false
= remove_range(right_orig
, min
, rl_min(left_orig
));
931 if (sval_cmp(rl_min(left_orig
), rl_min(right_orig
)) == 0)
932 right_false
= remove_range(right_false
, rl_min(left_orig
), rl_min(left_orig
));
933 if (sval_cmp(rl_max(left_orig
), rl_max(right_orig
)) == 0)
934 left_false
= remove_range(left_false
, rl_max(left_orig
), rl_max(left_orig
));
937 case SPECIAL_UNSIGNED_GT
:
938 left_true
= remove_range(left_orig
, min
, rl_min(right_orig
));
939 if (!sval_is_max(rl_max(right_orig
)))
940 left_false
= remove_range(left_orig
, add_one(rl_max(right_orig
)), max
);
942 right_true
= remove_range(right_orig
, rl_max(left_orig
), max
);
943 if (!sval_is_min(rl_min(left_orig
)))
944 right_false
= remove_range(right_orig
, min
, sub_one(rl_min(left_orig
)));
946 case SPECIAL_NOTEQUAL
:
947 if (!sval_is_max(rl_max(right_orig
)))
948 left_false
= remove_range(left_false
, add_one(rl_max(right_orig
)), max
);
949 if (!sval_is_min(rl_min(right_orig
)))
950 left_false
= remove_range(left_false
, min
, sub_one(rl_min(right_orig
)));
951 if (sval_cmp(rl_min(right_orig
), rl_max(right_orig
)) == 0)
952 left_true
= remove_range(left_orig
, rl_min(right_orig
), rl_min(right_orig
));
954 if (!sval_is_max(rl_max(left_orig
)))
955 right_false
= remove_range(right_false
, add_one(rl_max(left_orig
)), max
);
956 if (!sval_is_min(rl_min(left_orig
)))
957 right_false
= remove_range(right_false
, min
, sub_one(rl_min(left_orig
)));
958 if (sval_cmp(rl_min(left_orig
), rl_max(left_orig
)) == 0)
959 right_true
= remove_range(right_orig
, rl_min(left_orig
), rl_min(left_orig
));
965 left_true
= rl_truncate_cast(get_type(left
), left_true
);
966 left_false
= rl_truncate_cast(get_type(left
), left_false
);
967 right_true
= rl_truncate_cast(get_type(right
), right_true
);
968 right_false
= rl_truncate_cast(get_type(right
), right_false
);
970 left_true_state
= alloc_estate_rl(left_true
);
971 left_false_state
= alloc_estate_rl(left_false
);
972 right_true_state
= alloc_estate_rl(right_true
);
973 right_false_state
= alloc_estate_rl(right_false
);
977 case SPECIAL_UNSIGNED_LT
:
978 case SPECIAL_UNSIGNED_LTE
:
980 if (get_hard_max(right
, &dummy
))
981 estate_set_hard_max(left_true_state
);
982 if (get_hard_max(left
, &dummy
))
983 estate_set_hard_max(right_false_state
);
986 case SPECIAL_UNSIGNED_GT
:
987 case SPECIAL_UNSIGNED_GTE
:
989 if (get_hard_max(left
, &dummy
))
990 estate_set_hard_max(right_true_state
);
991 if (get_hard_max(right
, &dummy
))
992 estate_set_hard_max(left_false_state
);
998 case SPECIAL_UNSIGNED_LT
:
999 case SPECIAL_UNSIGNED_LTE
:
1001 if (get_hard_max(right
, &hard_max
)) {
1002 if (op
== '<' || op
== SPECIAL_UNSIGNED_LT
)
1004 estate_set_fuzzy_max(left_true_state
, hard_max
);
1006 if (get_implied_value(right
, &hard_max
)) {
1007 if (op
== SPECIAL_UNSIGNED_LTE
||
1010 estate_set_fuzzy_max(left_false_state
, hard_max
);
1012 if (get_hard_max(left
, &hard_max
)) {
1013 if (op
== SPECIAL_UNSIGNED_LTE
||
1016 estate_set_fuzzy_max(right_false_state
, hard_max
);
1018 if (get_implied_value(left
, &hard_max
)) {
1019 if (op
== '<' || op
== SPECIAL_UNSIGNED_LT
)
1021 estate_set_fuzzy_max(right_true_state
, hard_max
);
1025 case SPECIAL_UNSIGNED_GT
:
1026 case SPECIAL_UNSIGNED_GTE
:
1028 if (get_hard_max(left
, &hard_max
)) {
1029 if (op
== '>' || op
== SPECIAL_UNSIGNED_GT
)
1031 estate_set_fuzzy_max(right_true_state
, hard_max
);
1033 if (get_implied_value(left
, &hard_max
)) {
1034 if (op
== SPECIAL_UNSIGNED_GTE
||
1037 estate_set_fuzzy_max(right_false_state
, hard_max
);
1039 if (get_hard_max(right
, &hard_max
)) {
1040 if (op
== SPECIAL_UNSIGNED_LTE
||
1043 estate_set_fuzzy_max(left_false_state
, hard_max
);
1045 if (get_implied_value(right
, &hard_max
)) {
1047 op
== SPECIAL_UNSIGNED_GT
)
1049 estate_set_fuzzy_max(left_true_state
, hard_max
);
1053 if (get_hard_max(left
, &hard_max
))
1054 estate_set_fuzzy_max(right_true_state
, hard_max
);
1055 if (get_hard_max(right
, &hard_max
))
1056 estate_set_fuzzy_max(left_true_state
, hard_max
);
1060 if (get_hard_max(left
, &hard_max
)) {
1061 estate_set_hard_max(left_true_state
);
1062 estate_set_hard_max(left_false_state
);
1064 if (get_hard_max(right
, &hard_max
)) {
1065 estate_set_hard_max(right_true_state
);
1066 estate_set_hard_max(right_false_state
);
1069 if (left_postop
== SPECIAL_INCREMENT
) {
1070 left_true_state
= increment_state(left_true_state
);
1071 left_false_state
= increment_state(left_false_state
);
1073 if (left_postop
== SPECIAL_DECREMENT
) {
1074 left_true_state
= decrement_state(left_true_state
);
1075 left_false_state
= decrement_state(left_false_state
);
1077 if (right_postop
== SPECIAL_INCREMENT
) {
1078 right_true_state
= increment_state(right_true_state
);
1079 right_false_state
= increment_state(right_false_state
);
1081 if (right_postop
== SPECIAL_DECREMENT
) {
1082 right_true_state
= decrement_state(right_true_state
);
1083 right_false_state
= decrement_state(right_false_state
);
1086 set_extra_expr_true_false(left
, left_true_state
, left_false_state
);
1087 set_extra_expr_true_false(right
, right_true_state
, right_false_state
);
1090 static int opposite_op(int op
)
1101 static int is_simple_math(struct expression
*expr
)
1105 if (expr
->type
!= EXPR_BINOP
)
1107 if (!opposite_op(expr
->op
))
1112 static void move_known_values(struct expression
**left_p
, struct expression
**right_p
)
1114 struct expression
*left
= *left_p
;
1115 struct expression
*right
= *right_p
;
1118 if (get_implied_value(left
, &sval
)) {
1119 if (!is_simple_math(right
))
1121 if (right
->op
== '+' && get_value(right
->left
, &sval
)) {
1122 *left_p
= binop_expression(left
, opposite_op(right
->op
), right
->left
);
1123 *right_p
= right
->right
;
1126 if (get_value(right
->right
, &sval
)) {
1127 *left_p
= binop_expression(left
, opposite_op(right
->op
), right
->right
);
1128 *right_p
= right
->left
;
1133 if (get_implied_value(right
, &sval
)) {
1134 if (!is_simple_math(left
))
1136 if (left
->op
== '+' && get_value(left
->left
, &sval
)) {
1137 *right_p
= binop_expression(right
, opposite_op(left
->op
), left
->left
);
1138 *left_p
= left
->right
;
1142 if (get_value(left
->right
, &sval
)) {
1143 *right_p
= binop_expression(right
, opposite_op(left
->op
), left
->right
);
1144 *left_p
= left
->left
;
1151 static int match_func_comparison(struct expression
*expr
)
1153 struct expression
*left
= strip_expr(expr
->left
);
1154 struct expression
*right
= strip_expr(expr
->right
);
1158 * fixme: think about this harder. We should always be trying to limit
1159 * the non-call side as well. If we can't determine the limitter does
1160 * that mean we aren't querying the database and are missing important
1164 if (left
->type
== EXPR_CALL
) {
1165 if (get_implied_value(left
, &sval
)) {
1166 handle_comparison(get_type(expr
), left
, expr
->op
, right
);
1169 if (!get_implied_value(right
, &sval
))
1171 function_comparison(expr
->op
, left
, sval
, 1);
1175 if (right
->type
== EXPR_CALL
) {
1176 if (get_implied_value(right
, &sval
)) {
1177 handle_comparison(get_type(expr
), left
, expr
->op
, right
);
1180 if (!get_implied_value(left
, &sval
))
1182 function_comparison(expr
->op
, right
, sval
, 0);
1189 static void match_comparison(struct expression
*expr
)
1191 struct expression
*left_orig
= strip_expr(expr
->left
);
1192 struct expression
*right_orig
= strip_expr(expr
->right
);
1193 struct expression
*left
, *right
;
1194 struct expression
*prev
;
1195 struct symbol
*type
;
1197 if (match_func_comparison(expr
))
1200 type
= get_type(expr
);
1202 type
= &llong_ctype
;
1206 move_known_values(&left
, &right
);
1207 handle_comparison(type
, left
, expr
->op
, right
);
1209 prev
= get_assigned_expr(left_orig
);
1210 if (is_simple_math(prev
) && has_variable(prev
, left_orig
) == 0) {
1213 move_known_values(&left
, &right
);
1214 handle_comparison(type
, left
, expr
->op
, right
);
1217 prev
= get_assigned_expr(right_orig
);
1218 if (is_simple_math(prev
) && has_variable(prev
, right_orig
) == 0) {
1221 move_known_values(&left
, &right
);
1222 handle_comparison(type
, left
, expr
->op
, right
);
1226 static void handle_AND_condition(struct expression
*expr
)
1228 struct range_list
*rl
= NULL
;
1231 if (get_implied_value(expr
->left
, &known
) && known
.value
> 0) {
1233 get_absolute_rl(expr
->right
, &rl
);
1234 rl
= remove_range(rl
, sval_type_val(known
.type
, 0), known
);
1235 set_extra_expr_true_false(expr
->right
, alloc_estate_rl(rl
), NULL
);
1239 if (get_implied_value(expr
->right
, &known
) && known
.value
> 0) {
1241 get_absolute_rl(expr
->left
, &rl
);
1242 rl
= remove_range(rl
, sval_type_val(known
.type
, 0), known
);
1243 set_extra_expr_true_false(expr
->left
, alloc_estate_rl(rl
), NULL
);
1248 /* this is actually hooked from smatch_implied.c... it's hacky, yes */
1249 void __extra_match_condition(struct expression
*expr
)
1253 struct smatch_state
*pre_state
;
1254 struct smatch_state
*true_state
;
1255 struct smatch_state
*false_state
;
1257 expr
= strip_expr(expr
);
1258 switch (expr
->type
) {
1260 function_comparison(SPECIAL_NOTEQUAL
, expr
, ll_to_sval(0), 1);
1267 zero
= sval_blank(expr
);
1270 name
= expr_to_var_sym(expr
, &sym
);
1273 pre_state
= get_state(my_id
, name
, sym
);
1274 true_state
= estate_filter_sval(pre_state
, zero
);
1275 if (possibly_true(expr
, SPECIAL_EQUAL
, zero_expr()))
1276 false_state
= alloc_estate_sval(zero
);
1278 false_state
= alloc_estate_empty();
1279 set_extra_true_false(name
, sym
, true_state
, false_state
);
1284 match_comparison(expr
);
1286 case EXPR_ASSIGNMENT
:
1287 __extra_match_condition(expr
->left
);
1290 if (expr
->op
== '&')
1291 handle_AND_condition(expr
);
1296 static void assume_indexes_are_valid(struct expression
*expr
)
1298 struct expression
*array_expr
;
1300 struct expression
*offset
;
1301 struct symbol
*offset_type
;
1302 struct range_list
*rl_before
;
1303 struct range_list
*rl_after
;
1304 struct range_list
*filter
= NULL
;
1307 expr
= strip_expr(expr
);
1308 if (!is_array(expr
))
1311 offset
= get_array_offset(expr
);
1312 offset_type
= get_type(offset
);
1313 if (offset_type
&& type_signed(offset_type
)) {
1314 filter
= alloc_rl(sval_type_min(offset_type
),
1315 sval_type_val(offset_type
, -1));
1318 array_expr
= strip_parens(expr
->unop
->left
);
1319 array_size
= get_real_array_size(array_expr
);
1320 if (array_size
> 1) {
1321 size
= sval_type_val(offset_type
, array_size
);
1322 add_range(&filter
, size
, sval_type_max(offset_type
));
1327 get_absolute_rl(offset
, &rl_before
);
1328 rl_after
= rl_filter(rl_before
, filter
);
1329 if (rl_equiv(rl_before
, rl_after
))
1331 set_extra_expr_nomod(offset
, alloc_estate_rl(rl_after
));
1334 /* returns 1 if it is not possible for expr to be value, otherwise returns 0 */
1335 int implied_not_equal(struct expression
*expr
, long long val
)
1337 return !possibly_false(expr
, SPECIAL_NOTEQUAL
, value_expr(val
));
1340 static void struct_member_callback(struct expression
*call
, int param
, char *printed_name
, struct smatch_state
*state
)
1342 if (estate_is_whole(state
))
1344 sql_insert_caller_info(call
, PARAM_VALUE
, param
, printed_name
, state
->name
);
1345 if (estate_has_fuzzy_max(state
))
1346 sql_insert_caller_info(call
, FUZZY_MAX
, param
, printed_name
,
1347 sval_to_str(estate_get_fuzzy_max(state
)));
1350 static void db_limited_before(void)
1352 unmatched_slist
= clone_slist(__get_cur_slist());
1355 static void db_limited_after(void)
1357 free_slist(&unmatched_slist
);
1360 static void db_param_limit_filter(struct expression
*expr
, int param
, char *key
, char *value
, int mod
)
1362 struct expression
*arg
;
1365 struct sm_state
*sm
;
1366 struct symbol
*type
;
1367 struct range_list
*rl
;
1368 struct range_list
*limit
;
1369 struct range_list
*new;
1371 while (expr
->type
== EXPR_ASSIGNMENT
)
1372 expr
= strip_expr(expr
->right
);
1373 if (expr
->type
!= EXPR_CALL
)
1376 arg
= get_argument_from_call_expr(expr
->args
, param
);
1380 name
= get_variable_from_key(arg
, key
, &sym
);
1384 sm
= get_sm_state(SMATCH_EXTRA
, name
, sym
);
1385 type
= get_member_type_from_key(arg
, key
);
1387 rl
= estate_rl(sm
->state
);
1389 rl
= alloc_whole_rl(type
);
1391 call_results_to_rl(expr
, type
, value
, &limit
);
1392 new = rl_intersection(rl
, limit
);
1394 /* We want to preserve the implications here */
1395 if (sm
&& rl_equiv(estate_rl(sm
->state
), new)) {
1399 set_extra_mod(name
, sym
, alloc_estate_rl(new));
1401 set_extra_nomod(name
, sym
, alloc_estate_rl(new));
1408 static void db_param_limit(struct expression
*expr
, int param
, char *key
, char *value
)
1410 db_param_limit_filter(expr
, param
, key
, value
, 0);
1413 static void db_param_filter(struct expression
*expr
, int param
, char *key
, char *value
)
1415 db_param_limit_filter(expr
, param
, key
, value
, 1);
1418 static void db_param_add(struct expression
*expr
, int param
, char *key
, char *value
)
1420 struct expression
*arg
;
1423 struct symbol
*type
;
1424 struct smatch_state
*state
;
1425 struct range_list
*added
= NULL
;
1426 struct range_list
*new;
1428 while (expr
->type
== EXPR_ASSIGNMENT
)
1429 expr
= strip_expr(expr
->right
);
1430 if (expr
->type
!= EXPR_CALL
)
1433 arg
= get_argument_from_call_expr(expr
->args
, param
);
1436 name
= get_variable_from_key(arg
, key
, &sym
);
1440 type
= get_member_type_from_key(arg
, key
);
1441 state
= get_state(SMATCH_EXTRA
, name
, sym
);
1443 call_results_to_rl(expr
, type
, value
, &added
);
1444 new = rl_union(estate_rl(state
), added
);
1446 new = alloc_whole_rl(type
);
1449 set_extra_mod(name
, sym
, alloc_estate_rl(new));
1454 static void db_returned_member_info(struct expression
*expr
, int param
, char *key
, char *value
)
1456 struct symbol
*type
;
1459 struct range_list
*rl
;
1461 if (expr
->type
!= EXPR_ASSIGNMENT
)
1464 name
= return_state_to_var_sym(expr
, param
, key
, &sym
);
1467 type
= get_member_type_from_key(expr
->left
, key
);
1470 call_results_to_rl(expr
->right
, type
, value
, &rl
);
1471 set_extra_mod(name
, sym
, alloc_estate_rl(rl
));
1477 static void returned_member_callback(int return_id
, char *return_ranges
, char *printed_name
, struct smatch_state
*state
)
1479 if (estate_is_whole(state
))
1482 /* these are handled in smatch_param_filter/set/limit.c */
1483 if (printed_name
[0] != '*' &&
1484 !strchr(printed_name
, '.') && !strchr(printed_name
, '-'))
1487 sql_insert_return_states(return_id
, return_ranges
, RETURN_VALUE
, -1,
1488 printed_name
, state
->name
);
1491 static void match_call_info(struct expression
*expr
)
1493 struct smatch_state
*state
;
1494 struct range_list
*rl
= NULL
;
1495 struct expression
*arg
;
1496 struct symbol
*type
;
1499 FOR_EACH_PTR(expr
->args
, arg
) {
1500 type
= get_arg_type(expr
->fn
, i
);
1502 if (get_implied_rl(arg
, &rl
))
1503 rl
= cast_rl(type
, rl
);
1505 rl
= cast_rl(type
, alloc_whole_rl(get_type(arg
)));
1507 if (!is_whole_rl(rl
))
1508 sql_insert_caller_info(expr
, PARAM_VALUE
, i
, "$$", show_rl(rl
));
1509 state
= get_state_expr(SMATCH_EXTRA
, arg
);
1510 if (estate_has_fuzzy_max(state
)) {
1511 sql_insert_caller_info(expr
, FUZZY_MAX
, i
, "$$",
1512 sval_to_str(estate_get_fuzzy_max(state
)));
1515 } END_FOR_EACH_PTR(arg
);
1518 static void set_param_value(const char *name
, struct symbol
*sym
, char *key
, char *value
)
1520 struct range_list
*rl
= NULL
;
1521 struct smatch_state
*state
;
1522 struct symbol
*type
;
1525 if (strcmp(key
, "*$$") == 0)
1526 snprintf(fullname
, sizeof(fullname
), "*%s", name
);
1527 else if (strncmp(key
, "$$", 2) == 0)
1528 snprintf(fullname
, 256, "%s%s", name
, key
+ 2);
1532 type
= get_member_type_from_key(symbol_expression(sym
), key
);
1533 str_to_rl(type
, value
, &rl
);
1534 state
= alloc_estate_rl(rl
);
1535 set_state(SMATCH_EXTRA
, fullname
, sym
, state
);
1538 static void set_param_hard_max(const char *name
, struct symbol
*sym
, char *key
, char *value
)
1540 struct range_list
*rl
= NULL
;
1541 struct smatch_state
*state
;
1542 struct symbol
*type
;
1546 if (strcmp(key
, "*$$") == 0)
1547 snprintf(fullname
, sizeof(fullname
), "*%s", name
);
1548 else if (strncmp(key
, "$$", 2) == 0)
1549 snprintf(fullname
, 256, "%s%s", name
, key
+ 2);
1553 state
= get_state(SMATCH_EXTRA
, fullname
, sym
);
1556 type
= get_member_type_from_key(symbol_expression(sym
), key
);
1557 str_to_rl(type
, value
, &rl
);
1558 if (!rl_to_sval(rl
, &max
))
1560 estate_set_fuzzy_max(state
, max
);
1563 void register_smatch_extra(int id
)
1567 add_merge_hook(my_id
, &merge_estates
);
1568 add_unmatched_state_hook(my_id
, &unmatched_state
);
1569 add_hook(&match_function_def
, FUNC_DEF_HOOK
);
1570 add_hook(&match_declarations
, DECLARATION_HOOK
);
1571 select_caller_info_hook(set_param_value
, PARAM_VALUE
);
1572 select_caller_info_hook(set_param_hard_max
, FUZZY_MAX
);
1573 select_return_states_hook(RETURN_VALUE
, &db_returned_member_info
);
1574 select_return_states_before(&db_limited_before
);
1575 select_return_states_hook(LIMITED_VALUE
, &db_param_limit
);
1576 select_return_states_hook(FILTER_VALUE
, &db_param_filter
);
1577 select_return_states_hook(ADDED_VALUE
, &db_param_add
);
1578 select_return_states_after(&db_limited_after
);
1581 void register_smatch_extra_late(int id
)
1583 add_hook(&match_dereferences
, DEREF_HOOK
);
1584 add_hook(&match_pointer_as_array
, OP_HOOK
);
1585 select_call_implies_hook(DEREFERENCE
, &set_param_dereferenced
);
1586 add_hook(&match_function_call
, FUNCTION_CALL_HOOK
);
1587 add_hook(&match_assign
, ASSIGNMENT_HOOK
);
1588 add_hook(&unop_expr
, OP_HOOK
);
1589 add_hook(&asm_expr
, ASM_HOOK
);
1591 add_hook(&match_call_info
, FUNCTION_CALL_HOOK
);
1592 add_member_info_callback(my_id
, struct_member_callback
);
1593 add_returned_member_callback(my_id
, returned_member_callback
);
1595 add_hook(&assume_indexes_are_valid
, OP_HOOK
);