check_debug.c

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