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_msg("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_msg("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_msg("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' = '%s'", sm->name, sm->state->name);
  86                 found = 1;
  87         } END_FOR_EACH_SM(sm);
  88
  89         if (!found)
  90                 sm_msg("%s: no states", check_arg->string->data);
  91 }
  92
  93 static void match_print_value(const char *fn, struct expression *expr, void *info)
  94 {
  95         struct stree *stree;
  96         struct sm_state *tmp;
  97         struct expression *arg_expr;
  98
  99         arg_expr = get_argument_from_call_expr(expr->args, 0);
 100         if (arg_expr->type != EXPR_STRING) {
 101                 sm_msg("error:  the argument to %s is supposed to be a string literal", fn);
 102                 return;
 103         }
 104
 105         stree = __get_cur_stree();
 106         FOR_EACH_MY_SM(SMATCH_EXTRA, stree, tmp) {
 107                 if (!strcmp(tmp->name, arg_expr->string->data))
 108                         sm_msg("%s = %s", tmp->name, tmp->state->name);
 109         } END_FOR_EACH_SM(tmp);
 110 }
 111
 112 static void match_print_implied(const char *fn, struct expression *expr, void *info)
 113 {
 114         struct expression *arg;
 115         struct range_list *rl = NULL;
 116         char *name;
 117
 118         arg = get_argument_from_call_expr(expr->args, 0);
 119         get_implied_rl(arg, &rl);
 120
 121         name = expr_to_str(arg);
 122         sm_msg("implied: %s = '%s'", name, show_rl(rl));
 123         free_string(name);
 124 }
 125
 126 static void match_print_implied_min(const char *fn, struct expression *expr, void *info)
 127 {
 128         struct expression *arg;
 129         sval_t sval;
 130         char *name;
 131
 132         arg = get_argument_from_call_expr(expr->args, 0);
 133         name = expr_to_str(arg);
 134
 135         if (get_implied_min(arg, &sval))
 136                 sm_msg("implied min: %s = %s", name, sval_to_str(sval));
 137         else
 138                 sm_msg("implied min: %s = <unknown>", name);
 139
 140         free_string(name);
 141 }
 142
 143 static void match_print_implied_max(const char *fn, struct expression *expr, void *info)
 144 {
 145         struct expression *arg;
 146         sval_t sval;
 147         char *name;
 148
 149         arg = get_argument_from_call_expr(expr->args, 0);
 150         name = expr_to_str(arg);
 151
 152         if (get_implied_max(arg, &sval))
 153                 sm_msg("implied max: %s = %s", name, sval_to_str(sval));
 154         else
 155                 sm_msg("implied max: %s = <unknown>", name);
 156
 157         free_string(name);
 158 }
 159
 160 static void match_user_rl(const char *fn, struct expression *expr, void *info)
 161 {
 162         struct expression *arg;
 163         struct range_list *rl;
 164         char *name;
 165
 166         arg = get_argument_from_call_expr(expr->args, 0);
 167         name = expr_to_str(arg);
 168
 169         get_user_rl(arg, &rl);
 170         sm_msg("user rl: '%s' = '%s'", name, show_rl(rl));
 171
 172         free_string(name);
 173 }
 174
 175 static void match_print_hard_max(const char *fn, struct expression *expr, void *info)
 176 {
 177         struct expression *arg;
 178         sval_t sval;
 179         char *name;
 180
 181         arg = get_argument_from_call_expr(expr->args, 0);
 182         name = expr_to_str(arg);
 183
 184         if (get_hard_max(arg, &sval))
 185                 sm_msg("hard max: %s = %s", name, sval_to_str(sval));
 186         else
 187                 sm_msg("hard max: %s = <unknown>", name);
 188
 189         free_string(name);
 190 }
 191
 192 static void match_print_fuzzy_max(const char *fn, struct expression *expr, void *info)
 193 {
 194         struct expression *arg;
 195         sval_t sval;
 196         char *name;
 197
 198         arg = get_argument_from_call_expr(expr->args, 0);
 199         name = expr_to_str(arg);
 200
 201         if (get_fuzzy_max(arg, &sval))
 202                 sm_msg("fuzzy max: %s = %s", name, sval_to_str(sval));
 203         else
 204                 sm_msg("fuzzy max: %s = <unknown>", name);
 205
 206         free_string(name);
 207 }
 208
 209 static void match_print_absolute_min(const char *fn, struct expression *expr, void *info)
 210 {
 211         struct expression *arg;
 212         sval_t sval;
 213         char *name;
 214
 215         arg = get_argument_from_call_expr(expr->args, 0);
 216         name = expr_to_str(arg);
 217
 218         if (get_absolute_min(arg, &sval))
 219                 sm_msg("absolute min: %s = %s", name, sval_to_str(sval));
 220         else
 221                 sm_msg("absolute min: %s = <unknown>", name);
 222
 223         free_string(name);
 224 }
 225
 226 static void match_print_absolute_max(const char *fn, struct expression *expr, void *info)
 227 {
 228         struct expression *arg;
 229         sval_t sval;
 230         char *name;
 231
 232         arg = get_argument_from_call_expr(expr->args, 0);
 233         get_absolute_max(arg, &sval);
 234
 235         name = expr_to_str(arg);
 236         sm_msg("absolute max: %s = %s", name, sval_to_str(sval));
 237         free_string(name);
 238 }
 239
 240 static void match_sval_info(const char *fn, struct expression *expr, void *info)
 241 {
 242         struct expression *arg;
 243         sval_t sval;
 244         char *name;
 245
 246         arg = get_argument_from_call_expr(expr->args, 0);
 247         name = expr_to_str(arg);
 248
 249         if (!get_implied_value(arg, &sval)) {
 250                 sm_msg("no sval for '%s'", name);
 251                 goto free;
 252         }
 253
 254         sm_msg("implied: %s %c%d ->value = %llx", name, sval_unsigned(sval) ? 'u' : 's', sval_bits(sval), sval.value);
 255 free:
 256         free_string(name);
 257 }
 258
 259 static void match_member_name(const char *fn, struct expression *expr, void *info)
 260 {
 261         struct expression *arg;
 262         char *name, *member_name;
 263
 264         arg = get_argument_from_call_expr(expr->args, 0);
 265         name = expr_to_str(arg);
 266         member_name = get_member_name(arg);
 267         sm_msg("member name: '%s => %s'", name, member_name);
 268         free_string(member_name);
 269         free_string(name);
 270 }
 271
 272 static void print_possible(struct sm_state *sm)
 273 {
 274         struct sm_state *tmp;
 275
 276         sm_msg("Possible values for %s", sm->name);
 277         FOR_EACH_PTR(sm->possible, tmp) {
 278                 printf("%s\n", tmp->state->name);
 279         } END_FOR_EACH_PTR(tmp);
 280         sm_msg("===");
 281 }
 282
 283 static void match_possible(const char *fn, struct expression *expr, void *info)
 284 {
 285         struct stree *stree;
 286         struct sm_state *tmp;
 287         struct expression *arg_expr;
 288
 289         arg_expr = get_argument_from_call_expr(expr->args, 0);
 290         if (arg_expr->type != EXPR_STRING) {
 291                 sm_msg("error:  the argument to %s is supposed to be a string literal", fn);
 292                 return;
 293         }
 294
 295         stree = __get_cur_stree();
 296         FOR_EACH_MY_SM(SMATCH_EXTRA, stree, tmp) {
 297                 if (!strcmp(tmp->name, arg_expr->string->data))
 298                         print_possible(tmp);
 299         } END_FOR_EACH_SM(tmp);
 300 }
 301
 302 static void match_strlen(const char *fn, struct expression *expr, void *info)
 303 {
 304         struct expression *arg;
 305         struct range_list *rl;
 306         char *name;
 307
 308         arg = get_argument_from_call_expr(expr->args, 0);
 309         get_implied_strlen(arg, &rl);
 310
 311         name = expr_to_str(arg);
 312         sm_msg("strlen: '%s' %s characters", name, show_rl(rl));
 313         free_string(name);
 314 }
 315
 316 static void match_buf_size(const char *fn, struct expression *expr, void *info)
 317 {
 318         struct expression *arg;
 319         int elements, bytes;
 320         char *name;
 321
 322         arg = get_argument_from_call_expr(expr->args, 0);
 323         elements = get_array_size(arg);
 324         bytes = get_array_size_bytes(arg);
 325
 326         name = expr_to_str(arg);
 327         sm_msg("buf size: '%s' %d elements, %d bytes", name, elements, bytes);
 328         free_string(name);
 329 }
 330
 331 static void match_buf_size_rl(const char *fn, struct expression *expr, void *info)
 332 {
 333         struct expression *arg;
 334         struct range_list *rl;
 335         int elements, bytes;
 336         char *name;
 337
 338         arg = get_argument_from_call_expr(expr->args, 0);
 339         rl = get_array_size_bytes_rl(arg);
 340         elements = get_array_size(arg);
 341         bytes = get_array_size_bytes(arg);
 342
 343         name = expr_to_str(arg);
 344         sm_msg("buf size: '%s' %s %d elements, %d bytes", name, show_rl(rl), elements, bytes);
 345         free_string(name);
 346 }
 347
 348 static void match_note(const char *fn, struct expression *expr, void *info)
 349 {
 350         struct expression *arg_expr;
 351
 352         arg_expr = get_argument_from_call_expr(expr->args, 0);
 353         if (arg_expr->type != EXPR_STRING) {
 354                 sm_msg("error:  the argument to %s is supposed to be a string literal", fn);
 355                 return;
 356         }
 357         sm_msg("%s", arg_expr->string->data);
 358 }
 359
 360 static void print_related(struct sm_state *sm)
 361 {
 362         struct relation *rel;
 363
 364         if (!estate_related(sm->state))
 365                 return;
 366
 367         sm_prefix();
 368         sm_printf("%s: ", sm->name);
 369         FOR_EACH_PTR(estate_related(sm->state), rel) {
 370                 sm_printf("%s ", rel->name);
 371         } END_FOR_EACH_PTR(rel);
 372         sm_printf("\n");
 373 }
 374
 375 static void match_dump_related(const char *fn, struct expression *expr, void *info)
 376 {
 377         struct stree *stree;
 378         struct sm_state *tmp;
 379
 380         stree = __get_cur_stree();
 381         FOR_EACH_MY_SM(SMATCH_EXTRA, stree, tmp) {
 382                 print_related(tmp);
 383         } END_FOR_EACH_SM(tmp);
 384 }
 385
 386 static void match_compare(const char *fn, struct expression *expr, void *info)
 387 {
 388         struct expression *one, *two;
 389         char *one_name, *two_name;
 390         int comparison;
 391         char buf[16];
 392
 393         one = get_argument_from_call_expr(expr->args, 0);
 394         two = get_argument_from_call_expr(expr->args, 1);
 395
 396         comparison = get_comparison(one, two);
 397         if (!comparison)
 398                 snprintf(buf, sizeof(buf), "<none>");
 399         else
 400                 snprintf(buf, sizeof(buf), "%s", show_special(comparison));
 401
 402         one_name = expr_to_str(one);
 403         two_name = expr_to_str(two);
 404
 405         sm_msg("%s %s %s", one_name, buf, two_name);
 406
 407         free_string(one_name);
 408         free_string(two_name);
 409 }
 410
 411 static void match_debug_on(const char *fn, struct expression *expr, void *info)
 412 {
 413         option_debug = 1;
 414 }
 415
 416 static void match_debug_check(const char *fn, struct expression *expr, void *info)
 417 {
 418         struct expression *arg;
 419
 420         arg = get_argument_from_call_expr(expr->args, 0);
 421         if (!arg || arg->type != EXPR_STRING)
 422                 return;
 423         option_debug_check = arg->string->data;
 424         sm_msg("arg = '%s'", option_debug_check);
 425 }
 426
 427 static void match_debug_off(const char *fn, struct expression *expr, void *info)
 428 {
 429         option_debug_check = (char *)"";
 430         option_debug = 0;
 431 }
 432
 433 static void match_local_debug_on(const char *fn, struct expression *expr, void *info)
 434 {
 435         local_debug = 1;
 436 }
 437
 438 static void match_local_debug_off(const char *fn, struct expression *expr, void *info)
 439 {
 440         local_debug = 0;
 441 }
 442
 443 static void match_debug_implied_on(const char *fn, struct expression *expr, void *info)
 444 {
 445         option_debug_implied = 1;
 446 }
 447
 448 static void match_debug_implied_off(const char *fn, struct expression *expr, void *info)
 449 {
 450         option_debug_implied = 0;
 451 }
 452
 453 static void match_about(const char *fn, struct expression *expr, void *info)
 454 {
 455         struct expression *arg;
 456         struct sm_state *sm;
 457         char *name;
 458
 459         sm_msg("---- about ----");
 460         match_print_implied(fn, expr, NULL);
 461         match_buf_size(fn, expr, NULL);
 462         match_strlen(fn, expr, NULL);
 463
 464         arg = get_argument_from_call_expr(expr->args, 0);
 465         name = expr_to_str(arg);
 466         if (!name) {
 467                 sm_msg("info: not a straight forward variable.");
 468                 return;
 469         }
 470
 471         FOR_EACH_SM(__get_cur_stree(), sm) {
 472                 if (strcmp(sm->name, name) != 0)
 473                         continue;
 474                 sm_msg("%s '%s' = '%s'", check_name(sm->owner), sm->name, sm->state->name);
 475         } END_FOR_EACH_SM(sm);
 476 }
 477
 478 static void match_intersection(const char *fn, struct expression *expr, void *info)
 479 {
 480         struct expression *one, *two;
 481         struct range_list *one_rl, *two_rl;
 482         struct range_list *res;
 483
 484         one = get_argument_from_call_expr(expr->args, 0);
 485         two = get_argument_from_call_expr(expr->args, 1);
 486
 487         get_absolute_rl(one, &one_rl);
 488         get_absolute_rl(two, &two_rl);
 489
 490         res = rl_intersection(one_rl, two_rl);
 491         sm_msg("'%s' intersect '%s' is '%s'", show_rl(one_rl), show_rl(two_rl), show_rl(res));
 492 }
 493
 494 static void match_type(const char *fn, struct expression *expr, void *info)
 495 {
 496         struct expression *one;
 497         struct symbol *type;
 498         char *name;
 499
 500         one = get_argument_from_call_expr(expr->args, 0);
 501         type = get_type(one);
 502         name = expr_to_str(one);
 503         sm_msg("type of '%s' is: '%s'", name, type_to_str(type));
 504         free_string(name);
 505 }
 506
 507 static struct stree *old_stree;
 508 static void trace_var(struct statement *stmt)
 509 {
 510         struct sm_state *sm, *old;
 511
 512         if (!trace_variable)
 513                 return;
 514         if (__inline_fn)
 515                 return;
 516
 517         FOR_EACH_SM(__get_cur_stree(), sm) {
 518                 if (strcmp(sm->name, trace_variable) != 0)
 519                         continue;
 520                 old = get_sm_state_stree(old_stree, sm->owner, sm->name, sm->sym);
 521                 if (old && old->state == sm->state)
 522                         continue;
 523                 sm_msg("[%d] %s '%s': '%s' => '%s'", stmt->type,
 524                        check_name(sm->owner),
 525                        sm->name, old ? old->state->name : "<none>", sm->state->name);
 526         } END_FOR_EACH_SM(sm);
 527
 528         free_stree(&old_stree);
 529         old_stree = clone_stree(__get_cur_stree());
 530 }
 531
 532 static void free_old_stree(struct symbol *sym)
 533 {
 534         free_stree(&old_stree);
 535 }
 536
 537 void check_debug(int id)
 538 {
 539         my_id = id;
 540         add_function_hook("__smatch_about", &match_about, NULL);
 541         add_function_hook("__smatch_all_values", &match_all_values, NULL);
 542         add_function_hook("__smatch_state", &match_state, NULL);
 543         add_function_hook("__smatch_states", &match_states, NULL);
 544         add_function_hook("__smatch_value", &match_print_value, NULL);
 545         add_function_hook("__smatch_implied", &match_print_implied, NULL);
 546         add_function_hook("__smatch_implied_min", &match_print_implied_min, NULL);
 547         add_function_hook("__smatch_implied_max", &match_print_implied_max, NULL);
 548         add_function_hook("__smatch_user_rl", &match_user_rl, NULL);
 549         add_function_hook("__smatch_hard_max", &match_print_hard_max, NULL);
 550         add_function_hook("__smatch_fuzzy_max", &match_print_fuzzy_max, NULL);
 551         add_function_hook("__smatch_absolute_min", &match_print_absolute_min, NULL);
 552         add_function_hook("__smatch_absolute_max", &match_print_absolute_max, NULL);
 553         add_function_hook("__smatch_sval_info", &match_sval_info, NULL);
 554         add_function_hook("__smatch_member_name", &match_member_name, NULL);
 555         add_function_hook("__smatch_possible", &match_possible, NULL);
 556         add_function_hook("__smatch_cur_stree", &match_cur_stree, NULL);
 557         add_function_hook("__smatch_strlen", &match_strlen, NULL);
 558         add_function_hook("__smatch_buf_size", &match_buf_size, NULL);
 559         add_function_hook("__smatch_buf_size_rl", &match_buf_size_rl, NULL);
 560         add_function_hook("__smatch_note", &match_note, NULL);
 561         add_function_hook("__smatch_dump_related", &match_dump_related, NULL);
 562         add_function_hook("__smatch_compare", &match_compare, NULL);
 563         add_function_hook("__smatch_debug_on", &match_debug_on, NULL);
 564         add_function_hook("__smatch_debug_check", &match_debug_check, NULL);
 565         add_function_hook("__smatch_debug_off", &match_debug_off, NULL);
 566         add_function_hook("__smatch_local_debug_on", &match_local_debug_on, NULL);
 567         add_function_hook("__smatch_local_debug_off", &match_local_debug_off, NULL);
 568         add_function_hook("__smatch_debug_implied_on", &match_debug_implied_on, NULL);
 569         add_function_hook("__smatch_debug_implied_off", &match_debug_implied_off, NULL);
 570         add_function_hook("__smatch_intersection", &match_intersection, NULL);
 571         add_function_hook("__smatch_type", &match_type, NULL);
 572
 573         add_hook(free_old_stree, END_FUNC_HOOK);
 574         add_hook(trace_var, STMT_HOOK_AFTER);
 575 }