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