1 /*
2 * Copyright (C) 2009 Dan Carpenter.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
16 */
17
18 #include <string.h>
19
20 #include "smatch.h"
21 #include "smatch_slist.h"
22 #include "smatch_extra.h"
23
24 void show_sname_alloc(void);
25 void show_data_range_alloc(void);
26 void show_ptrlist_alloc(void);
27 void show_rl_ptrlist_alloc(void);
28 void show_sm_state_alloc(void);
29
30 int local_debug;
31 static int my_id;
32 char *trace_variable;
33
34 static void match_all_values(const char *fn, struct expression *expr, void *info)
35 {
36 struct stree *stree;
37
38 stree = get_all_states_stree(SMATCH_EXTRA);
39 __print_stree(stree);
40 free_stree(&stree);
41 }
42
43 static void match_cur_stree(const char *fn, struct expression *expr, void *info)
44 {
45 __print_cur_stree();
46 }
47
48 static void match_state(const char *fn, struct expression *expr, void *info)
49 {
50 struct expression *check_arg, *state_arg;
51 struct sm_state *sm;
52 int found = 0;
53
54 check_arg = get_argument_from_call_expr(expr->args, 0);
55 if (check_arg->type != EXPR_STRING) {
56 sm_error("the check_name argument to %s is supposed to be a string literal", fn);
57 return;
58 }
59 state_arg = get_argument_from_call_expr(expr->args, 1);
60 if (!state_arg || state_arg->type != EXPR_STRING) {
61 sm_error("the state_name argument to %s is supposed to be a string literal", fn);
62 return;
63 }
64
65 FOR_EACH_SM(__get_cur_stree(), sm) {
66 if (strcmp(check_name(sm->owner), check_arg->string->data) != 0)
67 continue;
68 if (strcmp(sm->name, state_arg->string->data) != 0)
69 continue;
70 sm_msg("'%s' = '%s'", sm->name, sm->state->name);
71 found = 1;
72 } END_FOR_EACH_SM(sm);
73
74 if (!found)
75 sm_msg("%s '%s' not found", check_arg->string->data, state_arg->string->data);
76 }
77
78 static void match_states(const char *fn, struct expression *expr, void *info)
79 {
80 struct expression *check_arg;
81 struct sm_state *sm;
82 int found = 0;
83
84 check_arg = get_argument_from_call_expr(expr->args, 0);
85 if (check_arg->type != EXPR_STRING) {
86 sm_error("the check_name argument to %s is supposed to be a string literal", fn);
87 return;
88 }
89
90 FOR_EACH_SM(__get_cur_stree(), sm) {
91 if (!strstr(check_name(sm->owner), check_arg->string->data))
92 continue;
93 sm_msg("%s", show_sm(sm));
94 found = 1;
95 } END_FOR_EACH_SM(sm);
96
97 if (found)
98 return;
99
100 if (!id_from_name(check_arg->string->data))
101 sm_msg("invalid check name '%s'", check_arg->string->data);
102 else
103 sm_msg("%s: no states", check_arg->string->data);
104 }
105
106 static void match_print_value(const char *fn, struct expression *expr, void *info)
107 {
108 struct stree *stree;
109 struct sm_state *tmp;
110 struct expression *arg_expr;
111
112 arg_expr = get_argument_from_call_expr(expr->args, 0);
113 if (arg_expr->type != EXPR_STRING) {
114 sm_error("the argument to %s is supposed to be a string literal", fn);
115 return;
116 }
117
118 stree = __get_cur_stree();
119 FOR_EACH_MY_SM(SMATCH_EXTRA, stree, tmp) {
120 if (!strcmp(tmp->name, arg_expr->string->data))
121 sm_msg("%s = %s", tmp->name, tmp->state->name);
122 } END_FOR_EACH_SM(tmp);
123 }
124
125 static void match_print_known(const char *fn, struct expression *expr, void *info)
126 {
127 struct expression *arg;
128 struct range_list *rl = NULL;
129 char *name;
130 int known = 0;
131 sval_t sval;
132
133 arg = get_argument_from_call_expr(expr->args, 0);
134 if (get_value(arg, &sval))
135 known = 1;
136
137 get_implied_rl(arg, &rl);
138
139 name = expr_to_str(arg);
140 sm_msg("known: '%s' = '%s'. implied = '%s'", name, known ? sval_to_str(sval) : "<unknown>", show_rl(rl));
141 free_string(name);
142 }
143
144 static void match_print_implied(const char *fn, struct expression *expr, void *info)
145 {
146 struct expression *arg;
147 struct range_list *rl = NULL;
148 char *name;
149
150 arg = get_argument_from_call_expr(expr->args, 0);
151 get_implied_rl(arg, &rl);
152
153 name = expr_to_str(arg);
154 sm_msg("implied: %s = '%s'", name, show_rl(rl));
155 free_string(name);
156 }
157
158 static void match_real_absolute(const char *fn, struct expression *expr, void *info)
159 {
160 struct expression *arg;
161 struct range_list *rl = NULL;
162 char *name;
163
164 arg = get_argument_from_call_expr(expr->args, 0);
165 get_real_absolute_rl(arg, &rl);
166
167 name = expr_to_str(arg);
168 sm_msg("real absolute: %s = '%s'", name, show_rl(rl));
169 free_string(name);
170 }
171
172 static void match_print_implied_min(const char *fn, struct expression *expr, void *info)
173 {
174 struct expression *arg;
175 sval_t sval;
176 char *name;
177
178 arg = get_argument_from_call_expr(expr->args, 0);
179 name = expr_to_str(arg);
180
181 if (get_implied_min(arg, &sval))
182 sm_msg("implied min: %s = %s", name, sval_to_str(sval));
183 else
184 sm_msg("implied min: %s = <unknown>", name);
185
186 free_string(name);
187 }
188
189 static void match_print_implied_max(const char *fn, struct expression *expr, void *info)
190 {
191 struct expression *arg;
192 sval_t sval;
193 char *name;
194
195 arg = get_argument_from_call_expr(expr->args, 0);
196 name = expr_to_str(arg);
197
198 if (get_implied_max(arg, &sval))
199 sm_msg("implied max: %s = %s", name, sval_to_str(sval));
200 else
201 sm_msg("implied max: %s = <unknown>", name);
202
203 free_string(name);
204 }
205
206 static void match_user_rl(const char *fn, struct expression *expr, void *info)
207 {
208 struct expression *arg;
209 struct range_list *rl = NULL;
210 bool capped = false;
211 char *name;
212
213 arg = get_argument_from_call_expr(expr->args, 0);
214 name = expr_to_str(arg);
215
216 get_user_rl(arg, &rl);
217 if (rl)
218 capped = user_rl_capped(arg);
219 sm_msg("user rl: '%s' = '%s'%s", name, show_rl(rl), capped ? " (capped)" : "");
220
221 free_string(name);
222 }
223
224 static void match_capped(const char *fn, struct expression *expr, void *info)
225 {
226 struct expression *arg;
227 char *name;
228
229 arg = get_argument_from_call_expr(expr->args, 0);
230 name = expr_to_str(arg);
231 sm_msg("'%s' = '%s'", name, is_capped(arg) ? "capped" : "not capped");
232 free_string(name);
233 }
234
235 static void match_print_hard_max(const char *fn, struct expression *expr, void *info)
236 {
237 struct expression *arg;
238 sval_t sval;
239 char *name;
240
241 arg = get_argument_from_call_expr(expr->args, 0);
242 name = expr_to_str(arg);
243
244 if (get_hard_max(arg, &sval))
245 sm_msg("hard max: %s = %s", name, sval_to_str(sval));
246 else
247 sm_msg("hard max: %s = <unknown>", name);
248
249 free_string(name);
250 }
251
252 static void match_print_fuzzy_max(const char *fn, struct expression *expr, void *info)
253 {
254 struct expression *arg;
255 sval_t sval;
256 char *name;
257
258 arg = get_argument_from_call_expr(expr->args, 0);
259 name = expr_to_str(arg);
260
261 if (get_fuzzy_max(arg, &sval))
262 sm_msg("fuzzy max: %s = %s", name, sval_to_str(sval));
263 else
264 sm_msg("fuzzy max: %s = <unknown>", name);
265
266 free_string(name);
267 }
268
269 static void match_print_absolute(const char *fn, struct expression *expr, void *info)
270 {
271 struct expression *arg;
272 struct range_list *rl;
273 char *name;
274
275 arg = get_argument_from_call_expr(expr->args, 0);
276 name = expr_to_str(arg);
277
278 get_absolute_rl(arg, &rl);
279 sm_msg("absolute: %s = %s", name, show_rl(rl));
280
281 free_string(name);
282 }
283
284 static void match_print_absolute_min(const char *fn, struct expression *expr, void *info)
285 {
286 struct expression *arg;
287 sval_t sval;
288 char *name;
289
290 arg = get_argument_from_call_expr(expr->args, 0);
291 name = expr_to_str(arg);
292
293 if (get_absolute_min(arg, &sval))
294 sm_msg("absolute min: %s = %s", name, sval_to_str(sval));
295 else
296 sm_msg("absolute min: %s = <unknown>", name);
297
298 free_string(name);
299 }
300
301 static void match_print_absolute_max(const char *fn, struct expression *expr, void *info)
302 {
303 struct expression *arg;
304 sval_t sval;
305 char *name;
306
307 arg = get_argument_from_call_expr(expr->args, 0);
308 get_absolute_max(arg, &sval);
309
310 name = expr_to_str(arg);
311 sm_msg("absolute max: %s = %s", name, sval_to_str(sval));
312 free_string(name);
313 }
314
315 static void match_sval_info(const char *fn, struct expression *expr, void *info)
316 {
317 struct expression *arg;
318 sval_t sval;
319 char *name;
320
321 arg = get_argument_from_call_expr(expr->args, 0);
322 name = expr_to_str(arg);
323
324 if (!get_implied_value(arg, &sval)) {
325 sm_msg("no sval for '%s'", name);
326 goto free;
327 }
328
329 sm_msg("implied: %s %c%d ->value = %llx", name, sval_unsigned(sval) ? 'u' : 's', sval_bits(sval), sval.value);
330 free:
331 free_string(name);
332 }
333
334 static void match_member_name(const char *fn, struct expression *expr, void *info)
335 {
336 struct expression *arg;
337 char *name, *member_name;
338
339 arg = get_argument_from_call_expr(expr->args, 0);
340 name = expr_to_str(arg);
341 member_name = get_member_name(arg);
342 sm_msg("member name: '%s => %s'", name, member_name);
343 free_string(member_name);
344 free_string(name);
345 }
346
347 static void print_possible(struct sm_state *sm)
348 {
349 struct sm_state *tmp;
350
351 sm_msg("Possible values for %s", sm->name);
352 FOR_EACH_PTR(sm->possible, tmp) {
353 printf("%s\n", tmp->state->name);
354 } END_FOR_EACH_PTR(tmp);
355 sm_msg("===");
356 }
357
358 static void match_possible(const char *fn, struct expression *expr, void *info)
359 {
360 struct stree *stree;
361 struct sm_state *tmp;
362 struct expression *arg_expr;
363
364 arg_expr = get_argument_from_call_expr(expr->args, 0);
365 if (arg_expr->type != EXPR_STRING) {
366 sm_error("the argument to %s is supposed to be a string literal", fn);
367 return;
368 }
369
370 stree = __get_cur_stree();
371 FOR_EACH_MY_SM(SMATCH_EXTRA, stree, tmp) {
372 if (!strcmp(tmp->name, arg_expr->string->data))
373 print_possible(tmp);
374 } END_FOR_EACH_SM(tmp);
375 }
376
377 static void match_strlen(const char *fn, struct expression *expr, void *info)
378 {
379 struct expression *arg;
380 struct range_list *rl;
381 char *name;
382
383 arg = get_argument_from_call_expr(expr->args, 0);
384 get_implied_strlen(arg, &rl);
385
386 name = expr_to_str(arg);
387 sm_msg("strlen: '%s' %s characters", name, show_rl(rl));
388 free_string(name);
389 }
390
391 static void match_buf_size(const char *fn, struct expression *expr, void *info)
392 {
393 struct expression *arg, *comp;
394 struct range_list *rl;
395 int elements, bytes;
396 char *name;
397 char buf[256] = "";
398 int limit_type;
399 int n;
400 sval_t sval;
401
402 arg = get_argument_from_call_expr(expr->args, 0);
403
404 elements = get_array_size(arg);
405 bytes = get_array_size_bytes_max(arg);
406 rl = get_array_size_bytes_rl(arg);
407 comp = get_size_variable(arg, &limit_type);
408
409 name = expr_to_str(arg);
410 n = snprintf(buf, sizeof(buf), "buf size: '%s' %d elements, %d bytes", name, elements, bytes);
411 free_string(name);
412
413 if (!rl_to_sval(rl, &sval))
414 n += snprintf(buf + n, sizeof(buf) - n, " (rl = %s)", show_rl(rl));
415
416 if (comp) {
417 name = expr_to_str(comp);
418 snprintf(buf + n, sizeof(buf) - n, "[size_var=%s %s]", limit_type_str(limit_type), name);
419 free_string(name);
420 }
421 sm_msg("%s", buf);
422 }
423
424 static void match_note(const char *fn, struct expression *expr, void *info)
425 {
426 struct expression *arg_expr;
427
428 arg_expr = get_argument_from_call_expr(expr->args, 0);
429 if (arg_expr->type != EXPR_STRING) {
430 sm_error("the argument to %s is supposed to be a string literal", fn);
431 return;
432 }
433 sm_msg("%s", arg_expr->string->data);
434 }
435
436 static void print_related(struct sm_state *sm)
437 {
438 struct relation *rel;
439
440 if (!estate_related(sm->state))
441 return;
442
443 sm_prefix();
444 sm_printf("%s: ", sm->name);
445 FOR_EACH_PTR(estate_related(sm->state), rel) {
446 sm_printf("%s ", rel->name);
447 } END_FOR_EACH_PTR(rel);
448 sm_printf("\n");
449 }
450
451 static void match_dump_related(const char *fn, struct expression *expr, void *info)
452 {
453 struct stree *stree;
454 struct sm_state *tmp;
455
456 stree = __get_cur_stree();
457 FOR_EACH_MY_SM(SMATCH_EXTRA, stree, tmp) {
458 print_related(tmp);
459 } END_FOR_EACH_SM(tmp);
460 }
461
462 static void match_compare(const char *fn, struct expression *expr, void *info)
463 {
464 struct expression *one, *two;
465 char *one_name, *two_name;
466 int comparison;
467 char buf[16];
468
469 one = get_argument_from_call_expr(expr->args, 0);
470 two = get_argument_from_call_expr(expr->args, 1);
471
472 comparison = get_comparison(one, two);
473 if (!comparison)
474 snprintf(buf, sizeof(buf), "<none>");
475 else
476 snprintf(buf, sizeof(buf), "%s", show_special(comparison));
477
478 one_name = expr_to_str(one);
479 two_name = expr_to_str(two);
480
481 sm_msg("%s %s %s", one_name, buf, two_name);
482
483 free_string(one_name);
484 free_string(two_name);
485 }
486
487 static void match_debug_on(const char *fn, struct expression *expr, void *info)
488 {
489 option_debug = 1;
490 }
491
492 static void match_debug_check(const char *fn, struct expression *expr, void *info)
493 {
494 struct expression *arg;
495
496 arg = get_argument_from_call_expr(expr->args, 0);
497 if (!arg || arg->type != EXPR_STRING)
498 return;
499 option_debug_check = arg->string->data;
500 sm_msg("arg = '%s'", option_debug_check);
501 }
502
503 static void match_debug_off(const char *fn, struct expression *expr, void *info)
504 {
505 option_debug_check = (char *)"";
506 option_debug = 0;
507 }
508
509 static void match_local_debug_on(const char *fn, struct expression *expr, void *info)
510 {
511 local_debug = 1;
512 }
513
514 static void match_local_debug_off(const char *fn, struct expression *expr, void *info)
515 {
516 local_debug = 0;
517 }
518
519 static void match_debug_db_on(const char *fn, struct expression *expr, void *info)
520 {
521 debug_db = 1;
522 }
523
524 static void match_debug_db_off(const char *fn, struct expression *expr, void *info)
525 {
526 debug_db = 0;
527 }
528
529 static void match_about(const char *fn, struct expression *expr, void *info)
530 {
531 struct expression *arg;
532 struct sm_state *sm;
533 char *name;
534
535 sm_msg("---- about ----");
536 match_print_implied(fn, expr, NULL);
537 match_buf_size(fn, expr, NULL);
538 match_strlen(fn, expr, NULL);
539 match_real_absolute(fn, expr, NULL);
540
541 arg = get_argument_from_call_expr(expr->args, 0);
542 name = expr_to_str(arg);
543 if (!name) {
544 sm_msg("info: not a straight forward variable.");
545 return;
546 }
547
548 FOR_EACH_SM(__get_cur_stree(), sm) {
549 if (strcmp(sm->name, name) != 0)
550 continue;
551 sm_msg("%s", show_sm(sm));
552 } END_FOR_EACH_SM(sm);
553 }
554
555 static void match_intersection(const char *fn, struct expression *expr, void *info)
556 {
557 struct expression *one, *two;
558 struct range_list *one_rl, *two_rl;
559 struct range_list *res;
560
561 one = get_argument_from_call_expr(expr->args, 0);
562 two = get_argument_from_call_expr(expr->args, 1);
563
564 get_absolute_rl(one, &one_rl);
565 get_absolute_rl(two, &two_rl);
566
567 res = rl_intersection(one_rl, two_rl);
568 sm_msg("'%s' intersect '%s' is '%s'", show_rl(one_rl), show_rl(two_rl), show_rl(res));
569 }
570
571 static void match_type(const char *fn, struct expression *expr, void *info)
572 {
573 struct expression *one;
574 struct symbol *type;
575 char *name;
576
577 one = get_argument_from_call_expr(expr->args, 0);
578 type = get_type(one);
579 name = expr_to_str(one);
580 sm_msg("type of '%s' is: '%s'", name, type_to_str(type));
581 free_string(name);
582 }
583
584 static int match_type_rl_return(struct expression *call, void *unused, struct range_list **rl)
585 {
586 struct expression *one, *two;
587 struct symbol *type;
588
589 one = get_argument_from_call_expr(call->args, 0);
590 type = get_type(one);
591
592 two = get_argument_from_call_expr(call->args, 1);
593 if (!two || two->type != EXPR_STRING) {
594 sm_msg("expected: __smatch_type_rl(type, \"string\")");
595 return 0;
596 }
597 call_results_to_rl(call, type, two->string->data, rl);
598 return 1;
599 }
600
601 static void print_left_right(struct sm_state *sm)
602 {
603 if (!sm)
604 return;
605 if (!sm->left && !sm->right)
606 return;
607
608 sm_printf("[ ");
609 if (sm->left)
610 sm_printf("(%d: %s->'%s')", get_stree_id(sm->left->pool), sm->left->name, sm->left->state->name);
611 else
612 sm_printf(" - ");
613
614
615 print_left_right(sm->left);
616
617 if (sm->right)
618 sm_printf("(%d: %s->'%s')", get_stree_id(sm->right->pool), sm->right->name, sm->right->state->name);
619 else
620 sm_printf(" - ");
621
622 print_left_right(sm->right);
623 }
624
625 static void match_print_merge_tree(const char *fn, struct expression *expr, void *info)
626 {
627 struct sm_state *sm;
628 struct expression *arg;
629 char *name;
630
631 arg = get_argument_from_call_expr(expr->args, 0);
632 name = expr_to_str(arg);
633
634 sm = get_sm_state_expr(SMATCH_EXTRA, arg);
635 if (!sm) {
636 sm_msg("no sm state for '%s'", name);
637 goto free;
638 }
639
640 sm_prefix();
641 sm_printf("merge tree: %s -> %s", name, sm->state->name);
642 print_left_right(sm);
643 sm_printf("\n");
644
645 free:
646 free_string(name);
647 }
648
649 static void match_print_stree_id(const char *fn, struct expression *expr, void *info)
650 {
651 sm_msg("stree_id %d", __stree_id);
652 }
653
654 static void match_mtag(const char *fn, struct expression *expr, void *info)
655 {
656 struct expression *arg;
657 char *name;
658 mtag_t tag = 0;
659 int offset = 0;
660
661 arg = get_argument_from_call_expr(expr->args, 0);
662 name = expr_to_str(arg);
663 expr_to_mtag_offset(arg, &tag, &offset);
664 sm_msg("mtag: '%s' => tag: %llu %d", name, tag, offset);
665 free_string(name);
666 }
667
668 static void match_mtag_data_offset(const char *fn, struct expression *expr, void *info)
669 {
670 struct expression *arg;
671 char *name;
672 mtag_t tag = 0;
673 int offset = -1;
674
675 arg = get_argument_from_call_expr(expr->args, 0);
676 name = expr_to_str(arg);
677 expr_to_mtag_offset(arg, &tag, &offset);
678 sm_msg("mtag: '%s' => tag: %lld, offset: %d", name, tag, offset);
679 free_string(name);
680 }
681
682 static void match_container(const char *fn, struct expression *expr, void *info)
683 {
684 struct expression *container, *x;
685 char *cont, *name, *str;
686
687 container = get_argument_from_call_expr(expr->args, 0);
688 x = get_argument_from_call_expr(expr->args, 1);
689
690 str = get_container_name(container, x);
691 cont = expr_to_str(container);
692 name = expr_to_str(x);
693 sm_msg("container: '%s' vs '%s' --> '%s'", cont, name, str);
694 free_string(cont);
695 free_string(name);
696 }
697
698 static void match_state_count(const char *fn, struct expression *expr, void *info)
699 {
700 sm_msg("state_count = %d\n", sm_state_counter);
701 }
702
703 static void match_mem(const char *fn, struct expression *expr, void *info)
704 {
705 show_sname_alloc();
706 show_data_range_alloc();
707 show_rl_ptrlist_alloc();
708 show_ptrlist_alloc();
709 sm_msg("%lu pools", get_pool_count());
710 sm_msg("%d strees", unfree_stree);
711 show_smatch_state_alloc();
712 show_sm_state_alloc();
713 }
714
715 static void match_exit(const char *fn, struct expression *expr, void *info)
716 {
717 exit(0);
718 }
719
720 static struct stree *old_stree;
721 static void trace_var(struct statement *stmt)
722 {
723 struct sm_state *sm, *old;
724 int printed = 0;
725
726 if (!trace_variable)
727 return;
728 if (__inline_fn)
729 return;
730
731 FOR_EACH_SM(__get_cur_stree(), sm) {
732 if (strcmp(sm->name, trace_variable) != 0)
733 continue;
734 old = get_sm_state_stree(old_stree, sm->owner, sm->name, sm->sym);
735 if (old && old->state == sm->state)
736 continue;
737 sm_msg("[%d] %s '%s': '%s' => '%s'", stmt->type,
738 check_name(sm->owner),
739 sm->name, old ? old->state->name : "<none>", sm->state->name);
740 printed = 1;
741 } END_FOR_EACH_SM(sm);
742
743 if (printed) {
744 free_stree(&old_stree);
745 old_stree = clone_stree(__get_cur_stree());
746 }
747 }
748
749 static void free_old_stree(struct symbol *sym)
750 {
751 free_stree(&old_stree);
752 }
753
754 void check_debug(int id)
755 {
756 my_id = id;
757 add_function_hook("__smatch_about", &match_about, NULL);
758 add_function_hook("__smatch_all_values", &match_all_values, NULL);
759 add_function_hook("__smatch_state", &match_state, NULL);
760 add_function_hook("__smatch_states", &match_states, NULL);
761 add_function_hook("__smatch_value", &match_print_value, NULL);
762 add_function_hook("__smatch_known", &match_print_known, NULL);
763 add_function_hook("__smatch_implied", &match_print_implied, NULL);
764 add_function_hook("__smatch_implied_min", &match_print_implied_min, NULL);
765 add_function_hook("__smatch_implied_max", &match_print_implied_max, NULL);
766 add_function_hook("__smatch_user_rl", &match_user_rl, NULL);
767 add_function_hook("__smatch_capped", &match_capped, NULL);
768 add_function_hook("__smatch_hard_max", &match_print_hard_max, NULL);
769 add_function_hook("__smatch_fuzzy_max", &match_print_fuzzy_max, NULL);
770 add_function_hook("__smatch_absolute", &match_print_absolute, NULL);
771 add_function_hook("__smatch_absolute_min", &match_print_absolute_min, NULL);
772 add_function_hook("__smatch_absolute_max", &match_print_absolute_max, NULL);
773 add_function_hook("__smatch_real_absolute", &match_real_absolute, NULL);
774 add_function_hook("__smatch_sval_info", &match_sval_info, NULL);
775 add_function_hook("__smatch_member_name", &match_member_name, NULL);
776 add_function_hook("__smatch_possible", &match_possible, NULL);
777 add_function_hook("__smatch_cur_stree", &match_cur_stree, NULL);
778 add_function_hook("__smatch_strlen", &match_strlen, NULL);
779 add_function_hook("__smatch_buf_size", &match_buf_size, NULL);
780 add_function_hook("__smatch_note", &match_note, NULL);
781 add_function_hook("__smatch_dump_related", &match_dump_related, NULL);
782 add_function_hook("__smatch_compare", &match_compare, NULL);
783 add_function_hook("__smatch_debug_on", &match_debug_on, NULL);
784 add_function_hook("__smatch_debug_check", &match_debug_check, NULL);
785 add_function_hook("__smatch_debug_off", &match_debug_off, NULL);
786 add_function_hook("__smatch_local_debug_on", &match_local_debug_on, NULL);
787 add_function_hook("__smatch_local_debug_off", &match_local_debug_off, NULL);
788 add_function_hook("__smatch_debug_db_on", &match_debug_db_on, NULL);
789 add_function_hook("__smatch_debug_db_off", &match_debug_db_off, NULL);
790 add_function_hook("__smatch_intersection", &match_intersection, NULL);
791 add_function_hook("__smatch_type", &match_type, NULL);
792 add_implied_return_hook("__smatch_type_rl_helper", &match_type_rl_return, NULL);
793 add_function_hook("__smatch_merge_tree", &match_print_merge_tree, NULL);
794 add_function_hook("__smatch_stree_id", &match_print_stree_id, NULL);
795 add_function_hook("__smatch_mtag", &match_mtag, NULL);
796 add_function_hook("__smatch_mtag_data", &match_mtag_data_offset, NULL);
797 add_function_hook("__smatch_state_count", &match_state_count, NULL);
798 add_function_hook("__smatch_mem", &match_mem, NULL);
799 add_function_hook("__smatch_exit", &match_exit, NULL);
800 add_function_hook("__smatch_container", &match_container, NULL);
801
802 add_hook(free_old_stree, AFTER_FUNC_HOOK);
803 add_hook(trace_var, STMT_HOOK_AFTER);
804 }