2 * Copyright (C) 2008 Dan Carpenter.
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.
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.
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
19 * smatch_extra.c is supposed to track the value of every variable.
31 #include "smatch_slist.h"
32 #include "smatch_extra.h"
36 struct string_list
*__ignored_macros
= NULL
;
37 static int in_warn_on_macro()
39 struct statement
*stmt
;
43 stmt
= get_current_statement();
46 macro
= get_macro_name(stmt
->pos
);
50 FOR_EACH_PTR(__ignored_macros
, tmp
) {
51 if (!strcmp(tmp
, macro
))
53 } END_FOR_EACH_PTR(tmp
);
57 typedef void (mod_hook
)(const char *name
, struct symbol
*sym
, struct smatch_state
*state
);
58 DECLARE_PTR_LIST(void_fn_list
, mod_hook
*);
59 static struct void_fn_list
*extra_mod_hooks
;
60 void add_extra_mod_hook(mod_hook
*fn
)
62 mod_hook
**p
= malloc(sizeof(mod_hook
*));
64 add_ptr_list(&extra_mod_hooks
, p
);
67 void call_extra_mod_hooks(const char *name
, struct symbol
*sym
, struct smatch_state
*state
)
71 FOR_EACH_PTR(extra_mod_hooks
, fn
) {
72 (*fn
)(name
, sym
, state
);
73 } END_FOR_EACH_PTR(fn
);
76 struct sm_state
*set_extra_mod(const char *name
, struct symbol
*sym
, struct smatch_state
*state
)
78 if (in_warn_on_macro())
80 remove_from_equiv(name
, sym
);
81 call_extra_mod_hooks(name
, sym
, state
);
82 return set_state(SMATCH_EXTRA
, name
, sym
, state
);
85 struct sm_state
*set_extra_expr_mod(struct expression
*expr
, struct smatch_state
*state
)
89 struct sm_state
*ret
= NULL
;
91 expr
= strip_expr(expr
);
92 name
= expr_to_var_sym(expr
, &sym
);
95 ret
= set_extra_mod(name
, sym
, state
);
101 void set_extra_nomod(const char *name
, struct symbol
*sym
, struct smatch_state
*state
)
103 struct relation
*rel
;
104 struct smatch_state
*orig_state
;
106 orig_state
= get_state(SMATCH_EXTRA
, name
, sym
);
108 if (!estate_related(orig_state
)) {
109 set_state(SMATCH_EXTRA
, name
, sym
, state
);
113 set_related(state
, estate_related(orig_state
));
114 FOR_EACH_PTR(estate_related(orig_state
), rel
) {
115 if (option_debug_related
)
116 sm_msg("updating related %s to %s", rel
->name
, state
->name
);
117 set_state(SMATCH_EXTRA
, rel
->name
, rel
->sym
, state
);
118 } END_FOR_EACH_PTR(rel
);
122 * This is for return_implies_state() hooks which modify a SMATCH_EXTRA state
124 void set_extra_expr_nomod(struct expression
*expr
, struct smatch_state
*state
)
129 name
= expr_to_var_sym(expr
, &sym
);
132 set_extra_nomod(name
, sym
, state
);
138 static void set_extra_true_false(const char *name
, struct symbol
*sym
,
139 struct smatch_state
*true_state
,
140 struct smatch_state
*false_state
)
142 struct relation
*rel
;
143 struct smatch_state
*orig_state
;
145 if (in_warn_on_macro())
148 orig_state
= get_state(SMATCH_EXTRA
, name
, sym
);
150 if (!estate_related(orig_state
)) {
151 set_true_false_states(SMATCH_EXTRA
, name
, sym
, true_state
, false_state
);
156 set_related(true_state
, estate_related(orig_state
));
158 set_related(false_state
, estate_related(orig_state
));
160 FOR_EACH_PTR(estate_related(orig_state
), rel
) {
161 set_true_false_states(SMATCH_EXTRA
, rel
->name
, rel
->sym
,
162 true_state
, false_state
);
163 } END_FOR_EACH_PTR(rel
);
166 static void set_extra_expr_true_false(struct expression
*expr
,
167 struct smatch_state
*true_state
,
168 struct smatch_state
*false_state
)
173 expr
= strip_expr(expr
);
174 name
= expr_to_var_sym(expr
, &sym
);
177 set_extra_true_false(name
, sym
, true_state
, false_state
);
182 static struct sm_state
*handle_canonical_while_count_down(struct statement
*loop
)
184 struct expression
*iter_var
;
185 struct expression
*condition
;
187 struct smatch_state
*estate
;
190 condition
= strip_expr(loop
->iterator_pre_condition
);
193 if (condition
->type
!= EXPR_PREOP
&& condition
->type
!= EXPR_POSTOP
)
195 if (condition
->op
!= SPECIAL_DECREMENT
)
198 iter_var
= condition
->unop
;
199 sm
= get_sm_state_expr(SMATCH_EXTRA
, iter_var
);
202 if (sval_cmp_val(estate_min(sm
->state
), 0) < 0)
204 start
= estate_max(sm
->state
);
205 if (sval_cmp_val(start
, 0) <= 0)
207 if (!sval_is_max(start
))
210 if (condition
->type
== EXPR_PREOP
) {
211 estate
= alloc_estate_range(sval_type_val(start
.type
, 1), start
);
212 if (estate_has_hard_max(sm
->state
))
213 estate_set_hard_max(estate
);
214 estate_copy_fuzzy_max(estate
, sm
->state
);
215 set_extra_expr_mod(iter_var
, estate
);
217 if (condition
->type
== EXPR_POSTOP
) {
218 estate
= alloc_estate_range(sval_type_val(start
.type
, 0), start
);
219 if (estate_has_hard_max(sm
->state
))
220 estate_set_hard_max(estate
);
221 estate_copy_fuzzy_max(estate
, sm
->state
);
222 set_extra_expr_mod(iter_var
, estate
);
224 return get_sm_state_expr(SMATCH_EXTRA
, iter_var
);
227 static struct sm_state
*handle_canonical_for_inc(struct expression
*iter_expr
,
228 struct expression
*condition
)
230 struct expression
*iter_var
;
232 struct smatch_state
*estate
;
233 sval_t start
, end
, max
;
235 iter_var
= iter_expr
->unop
;
236 sm
= get_sm_state_expr(SMATCH_EXTRA
, iter_var
);
239 if (!estate_get_single_value(sm
->state
, &start
))
241 if (get_implied_max(condition
->right
, &end
))
242 end
= sval_cast(get_type(iter_var
), end
);
244 end
= sval_type_max(get_type(iter_var
));
246 if (get_sm_state_expr(SMATCH_EXTRA
, condition
->left
) != sm
)
249 switch (condition
->op
) {
250 case SPECIAL_UNSIGNED_LT
:
251 case SPECIAL_NOTEQUAL
:
253 if (!sval_is_min(end
))
256 case SPECIAL_UNSIGNED_LTE
:
262 if (sval_cmp(end
, start
) < 0)
264 estate
= alloc_estate_range(start
, end
);
265 if (get_hard_max(condition
->right
, &max
)) {
266 estate_set_hard_max(estate
);
267 if (condition
->op
== '<' ||
268 condition
->op
== SPECIAL_UNSIGNED_LT
||
269 condition
->op
== SPECIAL_NOTEQUAL
)
271 estate_set_fuzzy_max(estate
, max
);
273 set_extra_expr_mod(iter_var
, estate
);
274 return get_sm_state_expr(SMATCH_EXTRA
, iter_var
);
277 static struct sm_state
*handle_canonical_for_dec(struct expression
*iter_expr
,
278 struct expression
*condition
)
280 struct expression
*iter_var
;
282 struct smatch_state
*estate
;
285 iter_var
= iter_expr
->unop
;
286 sm
= get_sm_state_expr(SMATCH_EXTRA
, iter_var
);
289 if (!estate_get_single_value(sm
->state
, &start
))
291 if (!get_implied_min(condition
->right
, &end
))
292 end
= sval_type_min(get_type(iter_var
));
293 if (get_sm_state_expr(SMATCH_EXTRA
, condition
->left
) != sm
)
296 switch (condition
->op
) {
297 case SPECIAL_NOTEQUAL
:
299 if (!sval_is_min(end
) && !sval_is_max(end
))
307 if (sval_cmp(end
, start
) > 0)
309 estate
= alloc_estate_range(end
, start
);
310 estate_set_hard_max(estate
);
311 estate_set_fuzzy_max(estate
, estate_get_fuzzy_max(estate
));
312 set_extra_expr_mod(iter_var
, estate
);
313 return get_sm_state_expr(SMATCH_EXTRA
, iter_var
);
316 static struct sm_state
*handle_canonical_for_loops(struct statement
*loop
)
318 struct expression
*iter_expr
;
319 struct expression
*condition
;
321 if (!loop
->iterator_post_statement
)
323 if (loop
->iterator_post_statement
->type
!= STMT_EXPRESSION
)
325 iter_expr
= loop
->iterator_post_statement
->expression
;
326 if (!loop
->iterator_pre_condition
)
328 if (loop
->iterator_pre_condition
->type
!= EXPR_COMPARE
)
330 condition
= loop
->iterator_pre_condition
;
332 if (iter_expr
->op
== SPECIAL_INCREMENT
)
333 return handle_canonical_for_inc(iter_expr
, condition
);
334 if (iter_expr
->op
== SPECIAL_DECREMENT
)
335 return handle_canonical_for_dec(iter_expr
, condition
);
339 struct sm_state
*__extra_handle_canonical_loops(struct statement
*loop
, struct stree
**stree
)
341 struct sm_state
*ret
;
343 __push_fake_cur_stree();
344 if (!loop
->iterator_post_statement
)
345 ret
= handle_canonical_while_count_down(loop
);
347 ret
= handle_canonical_for_loops(loop
);
348 *stree
= __pop_fake_cur_stree();
352 int __iterator_unchanged(struct sm_state
*sm
)
356 if (get_sm_state(my_id
, sm
->name
, sm
->sym
) == sm
)
361 static void while_count_down_after(struct sm_state
*sm
, struct expression
*condition
)
365 /* paranoid checking. prolly not needed */
366 condition
= strip_expr(condition
);
369 if (condition
->type
!= EXPR_PREOP
&& condition
->type
!= EXPR_POSTOP
)
371 if (condition
->op
!= SPECIAL_DECREMENT
)
373 after_value
= estate_min(sm
->state
);
375 set_extra_mod(sm
->name
, sm
->sym
, alloc_estate_sval(after_value
));
378 void __extra_pre_loop_hook_after(struct sm_state
*sm
,
379 struct statement
*iterator
,
380 struct expression
*condition
)
382 struct expression
*iter_expr
;
384 struct smatch_state
*state
;
387 while_count_down_after(sm
, condition
);
391 iter_expr
= iterator
->expression
;
393 if (condition
->type
!= EXPR_COMPARE
)
395 if (iter_expr
->op
== SPECIAL_INCREMENT
) {
396 limit
= sval_binop(estate_max(sm
->state
), '+',
397 sval_type_val(estate_type(sm
->state
), 1));
399 limit
= sval_binop(estate_min(sm
->state
), '-',
400 sval_type_val(estate_type(sm
->state
), 1));
402 if (!estate_has_hard_max(sm
->state
) && !__has_breaks()) {
403 if (iter_expr
->op
== SPECIAL_INCREMENT
)
404 state
= alloc_estate_range(estate_min(sm
->state
), limit
);
406 state
= alloc_estate_range(limit
, estate_max(sm
->state
));
408 state
= alloc_estate_sval(limit
);
410 if (!estate_has_hard_max(sm
->state
)) {
411 estate_clear_hard_max(state
);
413 if (estate_has_fuzzy_max(sm
->state
)) {
414 sval_t hmax
= estate_get_fuzzy_max(sm
->state
);
415 sval_t max
= estate_max(sm
->state
);
417 if (sval_cmp(hmax
, max
) != 0)
418 estate_clear_fuzzy_max(state
);
419 } else if (!estate_has_fuzzy_max(sm
->state
)) {
420 estate_clear_fuzzy_max(state
);
423 set_extra_mod(sm
->name
, sm
->sym
, state
);
426 static struct stree
*unmatched_stree
;
427 static struct smatch_state
*unmatched_state(struct sm_state
*sm
)
429 struct smatch_state
*state
;
431 if (unmatched_stree
) {
432 state
= get_state_stree(unmatched_stree
, SMATCH_EXTRA
, sm
->name
, sm
->sym
);
436 return alloc_estate_whole(estate_type(sm
->state
));
439 static void clear_the_pointed_at(struct expression
*expr
)
444 struct sm_state
*tmp
;
446 name
= expr_to_var_sym(expr
, &sym
);
450 stree
= __get_cur_stree();
451 FOR_EACH_MY_SM(SMATCH_EXTRA
, stree
, tmp
) {
452 if (tmp
->name
[0] != '*')
456 if (strcmp(tmp
->name
+ 1, name
) != 0)
458 set_extra_mod(tmp
->name
, tmp
->sym
, alloc_estate_whole(estate_type(tmp
->state
)));
459 } END_FOR_EACH_SM(tmp
);
465 static void match_function_call(struct expression
*expr
)
467 struct expression
*arg
;
468 struct expression
*tmp
;
470 /* if we have the db this is handled in smatch_function_hooks.c */
473 if (inlinable(expr
->fn
))
476 FOR_EACH_PTR(expr
->args
, arg
) {
477 tmp
= strip_expr(arg
);
478 if (tmp
->type
== EXPR_PREOP
&& tmp
->op
== '&')
479 set_extra_expr_mod(tmp
->unop
, alloc_estate_whole(get_type(tmp
->unop
)));
481 clear_the_pointed_at(tmp
);
482 } END_FOR_EACH_PTR(arg
);
485 static int types_equiv_or_pointer(struct symbol
*one
, struct symbol
*two
)
489 if (one
->type
== SYM_PTR
&& two
->type
== SYM_PTR
)
491 return types_equiv(one
, two
);
494 static void match_vanilla_assign(struct expression
*left
, struct expression
*right
)
496 struct range_list
*rl
= NULL
;
497 struct symbol
*right_sym
;
498 struct symbol
*left_type
;
499 struct symbol
*right_type
;
500 char *right_name
= NULL
;
504 struct smatch_state
*state
;
506 name
= expr_to_var_sym(left
, &sym
);
510 left_type
= get_type(left
);
511 right_type
= get_type(right
);
513 right_name
= expr_to_var_sym(right
, &right_sym
);
514 if (right_name
&& right_sym
&&
515 types_equiv_or_pointer(left_type
, right_type
)) {
516 set_equiv(left
, right
);
520 if (get_implied_rl(right
, &rl
)) {
521 rl
= cast_rl(left_type
, rl
);
522 state
= alloc_estate_rl(rl
);
523 if (get_hard_max(right
, &max
)) {
524 estate_set_hard_max(state
);
525 estate_set_fuzzy_max(state
, max
);
528 rl
= alloc_whole_rl(right_type
);
529 rl
= cast_rl(left_type
, rl
);
530 state
= alloc_estate_rl(rl
);
532 set_extra_mod(name
, sym
, state
);
534 free_string(right_name
);
537 static int op_remove_assign(int op
)
540 case SPECIAL_ADD_ASSIGN
:
542 case SPECIAL_SUB_ASSIGN
:
544 case SPECIAL_MUL_ASSIGN
:
546 case SPECIAL_DIV_ASSIGN
:
548 case SPECIAL_MOD_ASSIGN
:
550 case SPECIAL_AND_ASSIGN
:
552 case SPECIAL_OR_ASSIGN
:
554 case SPECIAL_XOR_ASSIGN
:
556 case SPECIAL_SHL_ASSIGN
:
557 return SPECIAL_LEFTSHIFT
;
558 case SPECIAL_SHR_ASSIGN
:
559 return SPECIAL_RIGHTSHIFT
;
565 static void match_assign(struct expression
*expr
)
567 struct range_list
*rl
= NULL
;
568 struct expression
*left
;
569 struct expression
*right
;
570 struct expression
*binop_expr
;
571 struct symbol
*left_type
;
572 struct symbol
*right_type
;
575 sval_t left_min
, left_max
;
576 sval_t right_min
, right_max
;
577 sval_t res_min
, res_max
;
579 left
= strip_expr(expr
->left
);
581 right
= strip_expr(expr
->right
);
582 while (right
->type
== EXPR_ASSIGNMENT
&& right
->op
== '=')
583 right
= strip_expr(right
->left
);
585 if (is_condition(expr
->right
))
586 return; /* handled in smatch_condition.c */
587 if (expr
->op
== '=' && right
->type
== EXPR_CALL
)
588 return; /* handled in smatch_function_hooks.c */
589 if (expr
->op
== '=') {
590 match_vanilla_assign(left
, right
);
594 name
= expr_to_var_sym(left
, &sym
);
598 left_type
= get_type(left
);
599 right_type
= get_type(right
);
601 res_min
= sval_type_min(left_type
);
602 res_max
= sval_type_max(left_type
);
605 case SPECIAL_ADD_ASSIGN
:
606 get_absolute_max(left
, &left_max
);
607 get_absolute_max(right
, &right_max
);
608 if (sval_binop_overflows(left_max
, '+', right_max
))
610 if (get_implied_min(left
, &left_min
) &&
611 !sval_is_negative_min(left_min
) &&
612 get_implied_min(right
, &right_min
) &&
613 !sval_is_negative_min(right_min
)) {
614 res_min
= sval_binop(left_min
, '+', right_min
);
615 res_min
= sval_cast(right_type
, res_min
);
617 if (inside_loop()) /* we are assuming loops don't lead to wrapping */
619 res_max
= sval_binop(left_max
, '+', right_max
);
620 res_max
= sval_cast(right_type
, res_max
);
622 case SPECIAL_SUB_ASSIGN
:
623 if (get_implied_max(left
, &left_max
) &&
624 !sval_is_max(left_max
) &&
625 get_implied_min(right
, &right_min
) &&
626 !sval_is_min(right_min
)) {
627 res_max
= sval_binop(left_max
, '-', right_min
);
628 res_max
= sval_cast(right_type
, res_max
);
632 if (get_implied_min(left
, &left_min
) &&
633 !sval_is_min(left_min
) &&
634 get_implied_max(right
, &right_max
) &&
635 !sval_is_max(right_max
)) {
636 res_min
= sval_binop(left_min
, '-', right_max
);
637 res_min
= sval_cast(right_type
, res_min
);
640 case SPECIAL_AND_ASSIGN
:
641 case SPECIAL_MOD_ASSIGN
:
642 case SPECIAL_SHL_ASSIGN
:
643 case SPECIAL_SHR_ASSIGN
:
644 case SPECIAL_OR_ASSIGN
:
645 case SPECIAL_XOR_ASSIGN
:
646 case SPECIAL_MUL_ASSIGN
:
647 case SPECIAL_DIV_ASSIGN
:
648 binop_expr
= binop_expression(expr
->left
,
649 op_remove_assign(expr
->op
),
651 if (get_absolute_rl(binop_expr
, &rl
)) {
652 rl
= cast_rl(left_type
, rl
);
653 set_extra_mod(name
, sym
, alloc_estate_rl(rl
));
658 rl
= cast_rl(left_type
, alloc_rl(res_min
, res_max
));
659 set_extra_mod(name
, sym
, alloc_estate_rl(rl
));
664 static struct smatch_state
*increment_state(struct smatch_state
*state
)
666 sval_t min
= estate_min(state
);
667 sval_t max
= estate_max(state
);
669 if (!estate_rl(state
))
673 max
= sval_type_max(max
.type
);
675 if (!sval_is_min(min
) && !sval_is_max(min
))
677 if (!sval_is_min(max
) && !sval_is_max(max
))
679 return alloc_estate_range(min
, max
);
682 static struct smatch_state
*decrement_state(struct smatch_state
*state
)
684 sval_t min
= estate_min(state
);
685 sval_t max
= estate_max(state
);
687 if (!estate_rl(state
))
691 min
= sval_type_min(min
.type
);
693 if (!sval_is_min(min
) && !sval_is_max(min
))
695 if (!sval_is_min(max
) && !sval_is_max(max
))
697 return alloc_estate_range(min
, max
);
700 static void unop_expr(struct expression
*expr
)
702 struct smatch_state
*state
;
704 if (expr
->smatch_flags
& Handled
)
708 case SPECIAL_INCREMENT
:
709 state
= get_state_expr(SMATCH_EXTRA
, expr
->unop
);
710 state
= increment_state(state
);
712 state
= alloc_estate_whole(get_type(expr
));
713 set_extra_expr_mod(expr
->unop
, state
);
715 case SPECIAL_DECREMENT
:
716 state
= get_state_expr(SMATCH_EXTRA
, expr
->unop
);
717 state
= decrement_state(state
);
719 state
= alloc_estate_whole(get_type(expr
));
720 set_extra_expr_mod(expr
->unop
, state
);
727 static void asm_expr(struct statement
*stmt
)
730 struct expression
*expr
;
734 FOR_EACH_PTR(stmt
->asm_outputs
, expr
) {
736 case 0: /* identifier */
737 case 1: /* constraint */
740 case 2: /* expression */
742 type
= get_type(strip_expr(expr
));
743 set_extra_expr_mod(expr
, alloc_estate_whole(type
));
746 } END_FOR_EACH_PTR(expr
);
749 static void delete_state_tracker(struct tracker
*t
)
751 remove_from_equiv(t
->name
, t
->sym
);
752 delete_state(t
->owner
, t
->name
, t
->sym
);
755 static void scoped_state_extra(const char *name
, struct symbol
*sym
)
759 t
= alloc_tracker(SMATCH_EXTRA
, name
, sym
);
760 add_scope_hook((scope_hook
*)&delete_state_tracker
, t
);
763 static void match_declarations(struct symbol
*sym
)
768 name
= sym
->ident
->name
;
769 if (!sym
->initializer
) {
770 set_state(SMATCH_EXTRA
, name
, sym
, alloc_estate_whole(get_real_base_type(sym
)));
771 scoped_state_extra(name
, sym
);
776 static void check_dereference(struct expression
*expr
)
778 if (outside_of_function())
780 set_extra_expr_nomod(expr
, alloc_estate_range(valid_ptr_min_sval
, valid_ptr_max_sval
));
783 static void match_dereferences(struct expression
*expr
)
785 if (expr
->type
!= EXPR_PREOP
)
787 check_dereference(expr
->unop
);
790 static void match_pointer_as_array(struct expression
*expr
)
794 check_dereference(expr
->unop
->left
);
797 static void set_param_dereferenced(struct expression
*arg
, char *unused
)
799 check_dereference(arg
);
802 static void match_function_def(struct symbol
*sym
)
806 FOR_EACH_PTR(sym
->ctype
.base_type
->arguments
, arg
) {
809 set_state(my_id
, arg
->ident
->name
, arg
, alloc_estate_whole(get_real_base_type(arg
)));
810 } END_FOR_EACH_PTR(arg
);
813 static sval_t
add_one(sval_t sval
)
819 static sval_t
sub_one(sval_t sval
)
825 static void handle_comparison(struct symbol
*type
, struct expression
*left
, int op
, struct expression
*right
)
827 struct range_list
*left_orig
;
828 struct range_list
*left_true
;
829 struct range_list
*left_false
;
830 struct range_list
*right_orig
;
831 struct range_list
*right_true
;
832 struct range_list
*right_false
;
833 struct smatch_state
*left_true_state
;
834 struct smatch_state
*left_false_state
;
835 struct smatch_state
*right_true_state
;
836 struct smatch_state
*right_false_state
;
837 sval_t min
, max
, dummy
, hard_max
;
839 int right_postop
= 0;
841 if (left
->op
== SPECIAL_INCREMENT
|| left
->op
== SPECIAL_DECREMENT
) {
842 if (left
->type
== EXPR_POSTOP
) {
843 left
->smatch_flags
|= Handled
;
844 left_postop
= left
->op
;
846 left
= strip_expr(left
->unop
);
848 while (left
->type
== EXPR_ASSIGNMENT
)
849 left
= strip_expr(left
->left
);
851 if (right
->op
== SPECIAL_INCREMENT
|| right
->op
== SPECIAL_DECREMENT
) {
852 if (right
->type
== EXPR_POSTOP
) {
853 right
->smatch_flags
|= Handled
;
854 right_postop
= right
->op
;
856 right
= strip_expr(right
->unop
);
859 if (get_implied_rl(left
, &left_orig
)) {
860 left_orig
= cast_rl(type
, left_orig
);
862 min
= sval_type_min(get_type(left
));
863 max
= sval_type_max(get_type(left
));
864 left_orig
= cast_rl(type
, alloc_rl(min
, max
));
867 if (get_implied_rl(right
, &right_orig
)) {
868 right_orig
= cast_rl(type
, right_orig
);
870 min
= sval_type_min(get_type(right
));
871 max
= sval_type_max(get_type(right
));
872 right_orig
= cast_rl(type
, alloc_rl(min
, max
));
874 min
= sval_type_min(type
);
875 max
= sval_type_max(type
);
877 left_true
= clone_rl(left_orig
);
878 left_false
= clone_rl(left_orig
);
879 right_true
= clone_rl(right_orig
);
880 right_false
= clone_rl(right_orig
);
884 case SPECIAL_UNSIGNED_LT
:
885 left_true
= remove_range(left_orig
, rl_max(right_orig
), max
);
886 if (!sval_is_min(rl_min(right_orig
))) {
887 left_false
= remove_range(left_orig
, min
, sub_one(rl_min(right_orig
)));
890 right_true
= remove_range(right_orig
, min
, rl_min(left_orig
));
891 if (!sval_is_max(rl_max(left_orig
)))
892 right_false
= remove_range(right_orig
, add_one(rl_max(left_orig
)), max
);
894 case SPECIAL_UNSIGNED_LTE
:
896 if (!sval_is_max(rl_max(right_orig
)))
897 left_true
= remove_range(left_orig
, add_one(rl_max(right_orig
)), max
);
898 left_false
= remove_range(left_orig
, min
, rl_min(right_orig
));
900 if (!sval_is_min(rl_min(left_orig
)))
901 right_true
= remove_range(right_orig
, min
, sub_one(rl_min(left_orig
)));
902 right_false
= remove_range(right_orig
, rl_max(left_orig
), max
);
904 if (sval_cmp(rl_min(left_orig
), rl_min(right_orig
)) == 0)
905 left_false
= remove_range(left_false
, rl_min(left_orig
), rl_min(left_orig
));
906 if (sval_cmp(rl_max(left_orig
), rl_max(right_orig
)) == 0)
907 right_false
= remove_range(right_false
, rl_max(left_orig
), rl_max(left_orig
));
910 if (!sval_is_max(rl_max(right_orig
))) {
911 left_true
= remove_range(left_true
, add_one(rl_max(right_orig
)), max
);
913 if (!sval_is_min(rl_min(right_orig
))) {
914 left_true
= remove_range(left_true
, min
, sub_one(rl_min(right_orig
)));
916 if (sval_cmp(rl_min(right_orig
), rl_max(right_orig
)) == 0)
917 left_false
= remove_range(left_orig
, rl_min(right_orig
), rl_min(right_orig
));
919 if (!sval_is_max(rl_max(left_orig
)))
920 right_true
= remove_range(right_true
, add_one(rl_max(left_orig
)), max
);
921 if (!sval_is_min(rl_min(left_orig
)))
922 right_true
= remove_range(right_true
, min
, sub_one(rl_min(left_orig
)));
923 if (sval_cmp(rl_min(left_orig
), rl_max(left_orig
)) == 0)
924 right_false
= remove_range(right_orig
, rl_min(left_orig
), rl_min(left_orig
));
926 case SPECIAL_UNSIGNED_GTE
:
928 if (!sval_is_min(rl_min(right_orig
)))
929 left_true
= remove_range(left_orig
, min
, sub_one(rl_min(right_orig
)));
930 left_false
= remove_range(left_orig
, rl_max(right_orig
), max
);
932 if (!sval_is_max(rl_max(left_orig
)))
933 right_true
= remove_range(right_orig
, add_one(rl_max(left_orig
)), max
);
934 right_false
= remove_range(right_orig
, min
, rl_min(left_orig
));
936 if (sval_cmp(rl_min(left_orig
), rl_min(right_orig
)) == 0)
937 right_false
= remove_range(right_false
, rl_min(left_orig
), rl_min(left_orig
));
938 if (sval_cmp(rl_max(left_orig
), rl_max(right_orig
)) == 0)
939 left_false
= remove_range(left_false
, rl_max(left_orig
), rl_max(left_orig
));
942 case SPECIAL_UNSIGNED_GT
:
943 left_true
= remove_range(left_orig
, min
, rl_min(right_orig
));
944 if (!sval_is_max(rl_max(right_orig
)))
945 left_false
= remove_range(left_orig
, add_one(rl_max(right_orig
)), max
);
947 right_true
= remove_range(right_orig
, rl_max(left_orig
), max
);
948 if (!sval_is_min(rl_min(left_orig
)))
949 right_false
= remove_range(right_orig
, min
, sub_one(rl_min(left_orig
)));
951 case SPECIAL_NOTEQUAL
:
952 if (!sval_is_max(rl_max(right_orig
)))
953 left_false
= remove_range(left_false
, add_one(rl_max(right_orig
)), max
);
954 if (!sval_is_min(rl_min(right_orig
)))
955 left_false
= remove_range(left_false
, min
, sub_one(rl_min(right_orig
)));
956 if (sval_cmp(rl_min(right_orig
), rl_max(right_orig
)) == 0)
957 left_true
= remove_range(left_orig
, rl_min(right_orig
), rl_min(right_orig
));
959 if (!sval_is_max(rl_max(left_orig
)))
960 right_false
= remove_range(right_false
, add_one(rl_max(left_orig
)), max
);
961 if (!sval_is_min(rl_min(left_orig
)))
962 right_false
= remove_range(right_false
, min
, sub_one(rl_min(left_orig
)));
963 if (sval_cmp(rl_min(left_orig
), rl_max(left_orig
)) == 0)
964 right_true
= remove_range(right_orig
, rl_min(left_orig
), rl_min(left_orig
));
970 left_true
= rl_truncate_cast(get_type(left
), left_true
);
971 left_false
= rl_truncate_cast(get_type(left
), left_false
);
972 right_true
= rl_truncate_cast(get_type(right
), right_true
);
973 right_false
= rl_truncate_cast(get_type(right
), right_false
);
975 left_true_state
= alloc_estate_rl(left_true
);
976 left_false_state
= alloc_estate_rl(left_false
);
977 right_true_state
= alloc_estate_rl(right_true
);
978 right_false_state
= alloc_estate_rl(right_false
);
982 case SPECIAL_UNSIGNED_LT
:
983 case SPECIAL_UNSIGNED_LTE
:
985 if (get_hard_max(right
, &dummy
))
986 estate_set_hard_max(left_true_state
);
987 if (get_hard_max(left
, &dummy
))
988 estate_set_hard_max(right_false_state
);
991 case SPECIAL_UNSIGNED_GT
:
992 case SPECIAL_UNSIGNED_GTE
:
994 if (get_hard_max(left
, &dummy
))
995 estate_set_hard_max(right_true_state
);
996 if (get_hard_max(right
, &dummy
))
997 estate_set_hard_max(left_false_state
);
1003 case SPECIAL_UNSIGNED_LT
:
1004 case SPECIAL_UNSIGNED_LTE
:
1006 if (get_hard_max(right
, &hard_max
)) {
1007 if (op
== '<' || op
== SPECIAL_UNSIGNED_LT
)
1009 estate_set_fuzzy_max(left_true_state
, hard_max
);
1011 if (get_implied_value(right
, &hard_max
)) {
1012 if (op
== SPECIAL_UNSIGNED_LTE
||
1015 estate_set_fuzzy_max(left_false_state
, hard_max
);
1017 if (get_hard_max(left
, &hard_max
)) {
1018 if (op
== SPECIAL_UNSIGNED_LTE
||
1021 estate_set_fuzzy_max(right_false_state
, hard_max
);
1023 if (get_implied_value(left
, &hard_max
)) {
1024 if (op
== '<' || op
== SPECIAL_UNSIGNED_LT
)
1026 estate_set_fuzzy_max(right_true_state
, hard_max
);
1030 case SPECIAL_UNSIGNED_GT
:
1031 case SPECIAL_UNSIGNED_GTE
:
1033 if (get_hard_max(left
, &hard_max
)) {
1034 if (op
== '>' || op
== SPECIAL_UNSIGNED_GT
)
1036 estate_set_fuzzy_max(right_true_state
, hard_max
);
1038 if (get_implied_value(left
, &hard_max
)) {
1039 if (op
== SPECIAL_UNSIGNED_GTE
||
1042 estate_set_fuzzy_max(right_false_state
, hard_max
);
1044 if (get_hard_max(right
, &hard_max
)) {
1045 if (op
== SPECIAL_UNSIGNED_LTE
||
1048 estate_set_fuzzy_max(left_false_state
, hard_max
);
1050 if (get_implied_value(right
, &hard_max
)) {
1052 op
== SPECIAL_UNSIGNED_GT
)
1054 estate_set_fuzzy_max(left_true_state
, hard_max
);
1058 if (get_hard_max(left
, &hard_max
))
1059 estate_set_fuzzy_max(right_true_state
, hard_max
);
1060 if (get_hard_max(right
, &hard_max
))
1061 estate_set_fuzzy_max(left_true_state
, hard_max
);
1065 if (get_hard_max(left
, &hard_max
)) {
1066 estate_set_hard_max(left_true_state
);
1067 estate_set_hard_max(left_false_state
);
1069 if (get_hard_max(right
, &hard_max
)) {
1070 estate_set_hard_max(right_true_state
);
1071 estate_set_hard_max(right_false_state
);
1074 if (left_postop
== SPECIAL_INCREMENT
) {
1075 left_true_state
= increment_state(left_true_state
);
1076 left_false_state
= increment_state(left_false_state
);
1078 if (left_postop
== SPECIAL_DECREMENT
) {
1079 left_true_state
= decrement_state(left_true_state
);
1080 left_false_state
= decrement_state(left_false_state
);
1082 if (right_postop
== SPECIAL_INCREMENT
) {
1083 right_true_state
= increment_state(right_true_state
);
1084 right_false_state
= increment_state(right_false_state
);
1086 if (right_postop
== SPECIAL_DECREMENT
) {
1087 right_true_state
= decrement_state(right_true_state
);
1088 right_false_state
= decrement_state(right_false_state
);
1091 set_extra_expr_true_false(left
, left_true_state
, left_false_state
);
1092 set_extra_expr_true_false(right
, right_true_state
, right_false_state
);
1095 static int opposite_op(int op
)
1106 static int is_simple_math(struct expression
*expr
)
1110 if (expr
->type
!= EXPR_BINOP
)
1112 if (!opposite_op(expr
->op
))
1117 static void move_known_values(struct expression
**left_p
, struct expression
**right_p
)
1119 struct expression
*left
= *left_p
;
1120 struct expression
*right
= *right_p
;
1123 if (get_implied_value(left
, &sval
)) {
1124 if (!is_simple_math(right
))
1126 if (right
->op
== '+' && get_value(right
->left
, &sval
)) {
1127 *left_p
= binop_expression(left
, opposite_op(right
->op
), right
->left
);
1128 *right_p
= right
->right
;
1131 if (get_value(right
->right
, &sval
)) {
1132 *left_p
= binop_expression(left
, opposite_op(right
->op
), right
->right
);
1133 *right_p
= right
->left
;
1138 if (get_implied_value(right
, &sval
)) {
1139 if (!is_simple_math(left
))
1141 if (left
->op
== '+' && get_value(left
->left
, &sval
)) {
1142 *right_p
= binop_expression(right
, opposite_op(left
->op
), left
->left
);
1143 *left_p
= left
->right
;
1147 if (get_value(left
->right
, &sval
)) {
1148 *right_p
= binop_expression(right
, opposite_op(left
->op
), left
->right
);
1149 *left_p
= left
->left
;
1156 static int match_func_comparison(struct expression
*expr
)
1158 struct expression
*left
= strip_expr(expr
->left
);
1159 struct expression
*right
= strip_expr(expr
->right
);
1163 * fixme: think about this harder. We should always be trying to limit
1164 * the non-call side as well. If we can't determine the limitter does
1165 * that mean we aren't querying the database and are missing important
1169 if (left
->type
== EXPR_CALL
) {
1170 if (get_implied_value(left
, &sval
)) {
1171 handle_comparison(get_type(expr
), left
, expr
->op
, right
);
1174 if (!get_implied_value(right
, &sval
))
1176 function_comparison(expr
->op
, left
, sval
, 1);
1180 if (right
->type
== EXPR_CALL
) {
1181 if (get_implied_value(right
, &sval
)) {
1182 handle_comparison(get_type(expr
), left
, expr
->op
, right
);
1185 if (!get_implied_value(left
, &sval
))
1187 function_comparison(expr
->op
, right
, sval
, 0);
1194 static void match_comparison(struct expression
*expr
)
1196 struct expression
*left_orig
= strip_expr(expr
->left
);
1197 struct expression
*right_orig
= strip_expr(expr
->right
);
1198 struct expression
*left
, *right
;
1199 struct expression
*prev
;
1200 struct symbol
*type
;
1202 if (match_func_comparison(expr
))
1205 type
= get_type(expr
);
1207 type
= &llong_ctype
;
1211 move_known_values(&left
, &right
);
1212 handle_comparison(type
, left
, expr
->op
, right
);
1214 prev
= get_assigned_expr(left_orig
);
1215 if (is_simple_math(prev
) && has_variable(prev
, left_orig
) == 0) {
1218 move_known_values(&left
, &right
);
1219 handle_comparison(type
, left
, expr
->op
, right
);
1222 prev
= get_assigned_expr(right_orig
);
1223 if (is_simple_math(prev
) && has_variable(prev
, right_orig
) == 0) {
1226 move_known_values(&left
, &right
);
1227 handle_comparison(type
, left
, expr
->op
, right
);
1231 static void handle_AND_condition(struct expression
*expr
)
1233 struct range_list
*rl
= NULL
;
1236 if (get_implied_value(expr
->left
, &known
) && known
.value
> 0) {
1238 get_absolute_rl(expr
->right
, &rl
);
1239 rl
= remove_range(rl
, sval_type_val(known
.type
, 0), known
);
1240 set_extra_expr_true_false(expr
->right
, alloc_estate_rl(rl
), NULL
);
1244 if (get_implied_value(expr
->right
, &known
) && known
.value
> 0) {
1246 get_absolute_rl(expr
->left
, &rl
);
1247 rl
= remove_range(rl
, sval_type_val(known
.type
, 0), known
);
1248 set_extra_expr_true_false(expr
->left
, alloc_estate_rl(rl
), NULL
);
1253 /* this is actually hooked from smatch_implied.c... it's hacky, yes */
1254 void __extra_match_condition(struct expression
*expr
)
1258 struct smatch_state
*pre_state
;
1259 struct smatch_state
*true_state
;
1260 struct smatch_state
*false_state
;
1262 expr
= strip_expr(expr
);
1263 switch (expr
->type
) {
1265 function_comparison(SPECIAL_NOTEQUAL
, expr
, ll_to_sval(0), 1);
1272 zero
= sval_blank(expr
);
1275 name
= expr_to_var_sym(expr
, &sym
);
1278 pre_state
= get_state(my_id
, name
, sym
);
1279 true_state
= estate_filter_sval(pre_state
, zero
);
1280 if (possibly_true(expr
, SPECIAL_EQUAL
, zero_expr()))
1281 false_state
= alloc_estate_sval(zero
);
1283 false_state
= alloc_estate_empty();
1284 set_extra_true_false(name
, sym
, true_state
, false_state
);
1289 match_comparison(expr
);
1291 case EXPR_ASSIGNMENT
:
1292 __extra_match_condition(expr
->left
);
1295 if (expr
->op
== '&')
1296 handle_AND_condition(expr
);
1301 static void assume_indexes_are_valid(struct expression
*expr
)
1303 struct expression
*array_expr
;
1305 struct expression
*offset
;
1306 struct symbol
*offset_type
;
1307 struct range_list
*rl_before
;
1308 struct range_list
*rl_after
;
1309 struct range_list
*filter
= NULL
;
1312 expr
= strip_expr(expr
);
1313 if (!is_array(expr
))
1316 offset
= get_array_offset(expr
);
1317 offset_type
= get_type(offset
);
1318 if (offset_type
&& type_signed(offset_type
)) {
1319 filter
= alloc_rl(sval_type_min(offset_type
),
1320 sval_type_val(offset_type
, -1));
1323 array_expr
= strip_parens(expr
->unop
->left
);
1324 array_size
= get_real_array_size(array_expr
);
1325 if (array_size
> 1) {
1326 size
= sval_type_val(offset_type
, array_size
);
1327 add_range(&filter
, size
, sval_type_max(offset_type
));
1332 get_absolute_rl(offset
, &rl_before
);
1333 rl_after
= rl_filter(rl_before
, filter
);
1334 if (rl_equiv(rl_before
, rl_after
))
1336 set_extra_expr_nomod(offset
, alloc_estate_rl(rl_after
));
1339 /* returns 1 if it is not possible for expr to be value, otherwise returns 0 */
1340 int implied_not_equal(struct expression
*expr
, long long val
)
1342 return !possibly_false(expr
, SPECIAL_NOTEQUAL
, value_expr(val
));
1345 static void struct_member_callback(struct expression
*call
, int param
, char *printed_name
, struct smatch_state
*state
)
1347 if (estate_is_whole(state
))
1349 sql_insert_caller_info(call
, PARAM_VALUE
, param
, printed_name
, state
->name
);
1350 if (estate_has_fuzzy_max(state
))
1351 sql_insert_caller_info(call
, FUZZY_MAX
, param
, printed_name
,
1352 sval_to_str(estate_get_fuzzy_max(state
)));
1355 static void db_limited_before(void)
1357 unmatched_stree
= clone_stree(__get_cur_stree());
1360 static void db_limited_after(void)
1362 free_stree(&unmatched_stree
);
1365 static void db_param_limit_filter(struct expression
*expr
, int param
, char *key
, char *value
, int mod
)
1367 struct expression
*arg
;
1370 struct sm_state
*sm
;
1371 struct symbol
*type
;
1372 struct range_list
*rl
;
1373 struct range_list
*limit
;
1374 struct range_list
*new;
1376 while (expr
->type
== EXPR_ASSIGNMENT
)
1377 expr
= strip_expr(expr
->right
);
1378 if (expr
->type
!= EXPR_CALL
)
1381 arg
= get_argument_from_call_expr(expr
->args
, param
);
1385 name
= get_variable_from_key(arg
, key
, &sym
);
1389 sm
= get_sm_state(SMATCH_EXTRA
, name
, sym
);
1390 type
= get_member_type_from_key(arg
, key
);
1392 rl
= estate_rl(sm
->state
);
1394 rl
= alloc_whole_rl(type
);
1396 call_results_to_rl(expr
, type
, value
, &limit
);
1397 new = rl_intersection(rl
, limit
);
1399 /* We want to preserve the implications here */
1400 if (sm
&& rl_equiv(estate_rl(sm
->state
), new)) {
1404 set_extra_mod(name
, sym
, alloc_estate_rl(new));
1406 set_extra_nomod(name
, sym
, alloc_estate_rl(new));
1413 static void db_param_limit(struct expression
*expr
, int param
, char *key
, char *value
)
1415 db_param_limit_filter(expr
, param
, key
, value
, 0);
1418 static void db_param_filter(struct expression
*expr
, int param
, char *key
, char *value
)
1420 db_param_limit_filter(expr
, param
, key
, value
, 1);
1423 static void db_param_add(struct expression
*expr
, int param
, char *key
, char *value
)
1425 struct expression
*arg
;
1428 struct symbol
*type
;
1429 struct smatch_state
*state
;
1430 struct range_list
*added
= NULL
;
1431 struct range_list
*new;
1433 while (expr
->type
== EXPR_ASSIGNMENT
)
1434 expr
= strip_expr(expr
->right
);
1435 if (expr
->type
!= EXPR_CALL
)
1438 arg
= get_argument_from_call_expr(expr
->args
, param
);
1441 name
= get_variable_from_key(arg
, key
, &sym
);
1445 type
= get_member_type_from_key(arg
, key
);
1446 state
= get_state(SMATCH_EXTRA
, name
, sym
);
1448 call_results_to_rl(expr
, type
, value
, &added
);
1449 new = rl_union(estate_rl(state
), added
);
1451 new = alloc_whole_rl(type
);
1454 set_extra_mod(name
, sym
, alloc_estate_rl(new));
1459 static void db_returned_member_info(struct expression
*expr
, int param
, char *key
, char *value
)
1461 struct symbol
*type
;
1464 struct range_list
*rl
;
1466 if (expr
->type
!= EXPR_ASSIGNMENT
)
1469 name
= return_state_to_var_sym(expr
, param
, key
, &sym
);
1472 type
= get_member_type_from_key(expr
->left
, key
);
1475 call_results_to_rl(expr
->right
, type
, value
, &rl
);
1476 set_extra_mod(name
, sym
, alloc_estate_rl(rl
));
1482 static void returned_member_callback(int return_id
, char *return_ranges
, char *printed_name
, struct smatch_state
*state
)
1484 if (estate_is_whole(state
))
1487 /* these are handled in smatch_param_filter/set/limit.c */
1488 if (printed_name
[0] != '*' &&
1489 !strchr(printed_name
, '.') && !strchr(printed_name
, '-'))
1492 sql_insert_return_states(return_id
, return_ranges
, RETURN_VALUE
, -1,
1493 printed_name
, state
->name
);
1496 static void match_call_info(struct expression
*expr
)
1498 struct smatch_state
*state
;
1499 struct range_list
*rl
= NULL
;
1500 struct expression
*arg
;
1501 struct symbol
*type
;
1504 FOR_EACH_PTR(expr
->args
, arg
) {
1505 type
= get_arg_type(expr
->fn
, i
);
1507 if (get_implied_rl(arg
, &rl
))
1508 rl
= cast_rl(type
, rl
);
1510 rl
= cast_rl(type
, alloc_whole_rl(get_type(arg
)));
1512 if (!is_whole_rl(rl
))
1513 sql_insert_caller_info(expr
, PARAM_VALUE
, i
, "$$", show_rl(rl
));
1514 state
= get_state_expr(SMATCH_EXTRA
, arg
);
1515 if (estate_has_fuzzy_max(state
)) {
1516 sql_insert_caller_info(expr
, FUZZY_MAX
, i
, "$$",
1517 sval_to_str(estate_get_fuzzy_max(state
)));
1520 } END_FOR_EACH_PTR(arg
);
1523 static void set_param_value(const char *name
, struct symbol
*sym
, char *key
, char *value
)
1525 struct range_list
*rl
= NULL
;
1526 struct smatch_state
*state
;
1527 struct symbol
*type
;
1530 if (strcmp(key
, "*$$") == 0)
1531 snprintf(fullname
, sizeof(fullname
), "*%s", name
);
1532 else if (strncmp(key
, "$$", 2) == 0)
1533 snprintf(fullname
, 256, "%s%s", name
, key
+ 2);
1537 type
= get_member_type_from_key(symbol_expression(sym
), key
);
1538 str_to_rl(type
, value
, &rl
);
1539 state
= alloc_estate_rl(rl
);
1540 set_state(SMATCH_EXTRA
, fullname
, sym
, state
);
1543 static void set_param_hard_max(const char *name
, struct symbol
*sym
, char *key
, char *value
)
1545 struct range_list
*rl
= NULL
;
1546 struct smatch_state
*state
;
1547 struct symbol
*type
;
1551 if (strcmp(key
, "*$$") == 0)
1552 snprintf(fullname
, sizeof(fullname
), "*%s", name
);
1553 else if (strncmp(key
, "$$", 2) == 0)
1554 snprintf(fullname
, 256, "%s%s", name
, key
+ 2);
1558 state
= get_state(SMATCH_EXTRA
, fullname
, sym
);
1561 type
= get_member_type_from_key(symbol_expression(sym
), key
);
1562 str_to_rl(type
, value
, &rl
);
1563 if (!rl_to_sval(rl
, &max
))
1565 estate_set_fuzzy_max(state
, max
);
1568 void register_smatch_extra(int id
)
1572 add_merge_hook(my_id
, &merge_estates
);
1573 add_unmatched_state_hook(my_id
, &unmatched_state
);
1574 add_hook(&match_function_def
, FUNC_DEF_HOOK
);
1575 add_hook(&match_declarations
, DECLARATION_HOOK
);
1576 select_caller_info_hook(set_param_value
, PARAM_VALUE
);
1577 select_caller_info_hook(set_param_hard_max
, FUZZY_MAX
);
1578 select_return_states_hook(RETURN_VALUE
, &db_returned_member_info
);
1579 select_return_states_before(&db_limited_before
);
1580 select_return_states_hook(LIMITED_VALUE
, &db_param_limit
);
1581 select_return_states_hook(FILTER_VALUE
, &db_param_filter
);
1582 select_return_states_hook(ADDED_VALUE
, &db_param_add
);
1583 select_return_states_after(&db_limited_after
);
1586 void register_smatch_extra_late(int id
)
1588 add_hook(&match_dereferences
, DEREF_HOOK
);
1589 add_hook(&match_pointer_as_array
, OP_HOOK
);
1590 select_call_implies_hook(DEREFERENCE
, &set_param_dereferenced
);
1591 add_hook(&match_function_call
, FUNCTION_CALL_HOOK
);
1592 add_hook(&match_assign
, ASSIGNMENT_HOOK
);
1593 add_hook(&unop_expr
, OP_HOOK
);
1594 add_hook(&asm_expr
, ASM_HOOK
);
1596 add_hook(&match_call_info
, FUNCTION_CALL_HOOK
);
1597 add_member_info_callback(my_id
, struct_member_callback
);
1598 add_returned_member_callback(my_id
, returned_member_callback
);
1600 add_hook(&assume_indexes_are_valid
, OP_HOOK
);