check_debug.c

   1 /*
   2  * sparse/check_debug.c
   3  *
   4  * Copyright (C) 2009 Dan Carpenter.
   5  *
   6  * Licensed under the Open Software License version 1.1
   7  *
   8  */
   9
  10 #include "smatch.h"
  11 #include "smatch_slist.h"
  12 #include "smatch_extra.h"
  13
  14 int local_debug;
  15 static int my_id;
  16
  17 static void match_all_values(const char *fn, struct expression *expr, void *info)
  18 {
  19         struct state_list *slist;
  20
  21         slist = get_all_states(SMATCH_EXTRA);
  22         __print_slist(slist);
  23         free_slist(&slist);
  24 }
  25
  26 static void match_cur_slist(const char *fn, struct expression *expr, void *info)
  27 {
  28         __print_cur_slist();
  29 }
  30
  31 static void match_state(const char *fn, struct expression *expr, void *info)
  32 {
  33         struct expression *check_arg, *state_arg;
  34         struct sm_state *sm;
  35         int found = 0;
  36
  37         check_arg = get_argument_from_call_expr(expr->args, 0);
  38         if (check_arg->type != EXPR_STRING) {
  39                 sm_msg("error:  the check_name argument to %s is supposed to be a string literal", fn);
  40                 return;
  41         }
  42         state_arg = get_argument_from_call_expr(expr->args, 1);
  43         if (state_arg->type != EXPR_STRING) {
  44                 sm_msg("error:  the state_name argument to %s is supposed to be a string literal", fn);
  45                 return;
  46         }
  47
  48         FOR_EACH_PTR(__get_cur_slist(), sm) {
  49                 if (strcmp(check_name(sm->owner), check_arg->string->data) != 0)
  50                         continue;
  51                 if (strcmp(sm->name, state_arg->string->data) != 0)
  52                         continue;
  53                 sm_msg("'%s' = '%s'", sm->name, sm->state->name);
  54                 found = 1;
  55         } END_FOR_EACH_PTR(sm);
  56
  57         if (!found)
  58                 sm_msg("%s '%s' not found", check_arg->string->data, state_arg->string->data);
  59 }
  60
  61 static void match_print_value(const char *fn, struct expression *expr, void *info)
  62 {
  63         struct state_list *slist;
  64         struct sm_state *tmp;
  65         struct expression *arg_expr;
  66
  67         arg_expr = get_argument_from_call_expr(expr->args, 0);
  68         if (arg_expr->type != EXPR_STRING) {
  69                 sm_msg("error:  the argument to %s is supposed to be a string literal", fn);
  70                 return;
  71         }
  72
  73         slist = get_all_states(SMATCH_EXTRA);
  74         FOR_EACH_PTR(slist, tmp) {
  75                 if (!strcmp(tmp->name, arg_expr->string->data))
  76                         sm_msg("%s = %s", tmp->name, tmp->state->name);
  77         } END_FOR_EACH_PTR(tmp);
  78         free_slist(&slist);
  79 }
  80
  81 static void match_print_implied(const char *fn, struct expression *expr, void *info)
  82 {
  83         struct expression *arg;
  84         struct range_list *rl = NULL;
  85         char *name;
  86
  87         arg = get_argument_from_call_expr(expr->args, 0);
  88         get_implied_rl(arg, &rl);
  89
  90         name = expr_to_str(arg);
  91         sm_msg("implied: %s = '%s'", name, show_rl(rl));
  92         free_string(name);
  93 }
  94
  95 static void match_print_implied_min(const char *fn, struct expression *expr, void *info)
  96 {
  97         struct expression *arg;
  98         sval_t sval;
  99         char *name;
 100
 101         arg = get_argument_from_call_expr(expr->args, 0);
 102         name = expr_to_str(arg);
 103
 104         if (get_implied_min(arg, &sval))
 105                 sm_msg("implied min: %s = %s", name, sval_to_str(sval));
 106         else
 107                 sm_msg("implied min: %s = <unknown>", name);
 108
 109         free_string(name);
 110 }
 111
 112 static void match_print_implied_max(const char *fn, struct expression *expr, void *info)
 113 {
 114         struct expression *arg;
 115         sval_t sval;
 116         char *name;
 117
 118         arg = get_argument_from_call_expr(expr->args, 0);
 119         name = expr_to_str(arg);
 120
 121         if (get_implied_max(arg, &sval))
 122                 sm_msg("implied max: %s = %s", name, sval_to_str(sval));
 123         else
 124                 sm_msg("implied max: %s = <unknown>", name);
 125
 126         free_string(name);
 127 }
 128
 129 static void match_print_hard_max(const char *fn, struct expression *expr, void *info)
 130 {
 131         struct expression *arg;
 132         sval_t sval;
 133         char *name;
 134
 135         arg = get_argument_from_call_expr(expr->args, 0);
 136         name = expr_to_str(arg);
 137
 138         if (get_hard_max(arg, &sval))
 139                 sm_msg("hard max: %s = %s", name, sval_to_str(sval));
 140         else
 141                 sm_msg("hard max: %s = <unknown>", name);
 142
 143         free_string(name);
 144 }
 145
 146 static void match_print_fuzzy_max(const char *fn, struct expression *expr, void *info)
 147 {
 148         struct expression *arg;
 149         sval_t sval;
 150         char *name;
 151
 152         arg = get_argument_from_call_expr(expr->args, 0);
 153         name = expr_to_str(arg);
 154
 155         if (get_fuzzy_max(arg, &sval))
 156                 sm_msg("fuzzy max: %s = %s", name, sval_to_str(sval));
 157         else
 158                 sm_msg("fuzzy max: %s = <unknown>", name);
 159
 160         free_string(name);
 161 }
 162
 163 static void match_print_absolute_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_absolute_min(arg, &sval))
 173                 sm_msg("absolute min: %s = %s", name, sval_to_str(sval));
 174         else
 175                 sm_msg("absolute min: %s = <unknown>", name);
 176
 177         free_string(name);
 178 }
 179
 180 static void match_print_absolute_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         get_absolute_max(arg, &sval);
 188
 189         name = expr_to_str(arg);
 190         sm_msg("absolute max: %s = %s", name, sval_to_str(sval));
 191         free_string(name);
 192 }
 193
 194 static void match_sval_info(const char *fn, struct expression *expr, void *info)
 195 {
 196         struct expression *arg;
 197         sval_t sval;
 198         char *name;
 199
 200         arg = get_argument_from_call_expr(expr->args, 0);
 201         name = expr_to_str(arg);
 202
 203         if (!get_implied_value(arg, &sval)) {
 204                 sm_msg("no sval for '%s'", name);
 205                 goto free;
 206         }
 207
 208         sm_msg("implied: %s %c%d ->value = %llx", name, sval_unsigned(sval) ? 'u' : 's', sval_bits(sval), sval.value);
 209 free:
 210         free_string(name);
 211 }
 212
 213 static void print_possible(struct sm_state *sm)
 214 {
 215         struct sm_state *tmp;
 216
 217         sm_msg("Possible values for %s", sm->name);
 218         FOR_EACH_PTR(sm->possible, tmp) {
 219                 printf("%s\n", tmp->state->name);
 220         } END_FOR_EACH_PTR(tmp);
 221         sm_msg("===");
 222 }
 223
 224 static void match_possible(const char *fn, struct expression *expr, void *info)
 225 {
 226         struct state_list *slist;
 227         struct sm_state *tmp;
 228         struct expression *arg_expr;
 229
 230         arg_expr = get_argument_from_call_expr(expr->args, 0);
 231         if (arg_expr->type != EXPR_STRING) {
 232                 sm_msg("error:  the argument to %s is supposed to be a string literal", fn);
 233                 return;
 234         }
 235
 236         slist = get_all_states(SMATCH_EXTRA);
 237         FOR_EACH_PTR(slist, tmp) {
 238                 if (!strcmp(tmp->name, arg_expr->string->data))
 239                         print_possible(tmp);
 240         } END_FOR_EACH_PTR(tmp);
 241         free_slist(&slist);
 242 }
 243
 244 static void match_buf_size(const char *fn, struct expression *expr, void *info)
 245 {
 246         struct expression *arg;
 247         int elements, bytes;
 248         char *name;
 249
 250         arg = get_argument_from_call_expr(expr->args, 0);
 251         elements = get_array_size(arg);
 252         bytes = get_array_size_bytes(arg);
 253
 254         name = expr_to_str(arg);
 255         sm_msg("buf size: '%s' %d elements, %d bytes", name, elements, bytes);
 256         free_string(name);
 257 }
 258
 259 static void match_note(const char *fn, struct expression *expr, void *info)
 260 {
 261         struct expression *arg_expr;
 262
 263         arg_expr = get_argument_from_call_expr(expr->args, 0);
 264         if (arg_expr->type != EXPR_STRING) {
 265                 sm_msg("error:  the argument to %s is supposed to be a string literal", fn);
 266                 return;
 267         }
 268         sm_msg("%s", arg_expr->string->data);
 269 }
 270
 271 static void print_related(struct sm_state *sm)
 272 {
 273         struct relation *rel;
 274
 275         if (!estate_related(sm->state))
 276                 return;
 277
 278         sm_prefix();
 279         sm_printf("%s: ", sm->name);
 280         FOR_EACH_PTR(estate_related(sm->state), rel) {
 281                 sm_printf("%s ", rel->name);
 282         } END_FOR_EACH_PTR(rel);
 283         sm_printf("\n");
 284 }
 285
 286 static void match_dump_related(const char *fn, struct expression *expr, void *info)
 287 {
 288         struct state_list *slist;
 289         struct sm_state *tmp;
 290
 291         slist = get_all_states(SMATCH_EXTRA);
 292         FOR_EACH_PTR(slist, tmp) {
 293                 print_related(tmp);
 294         } END_FOR_EACH_PTR(tmp);
 295         free_slist(&slist);
 296 }
 297
 298 static void match_compare(const char *fn, struct expression *expr, void *info)
 299 {
 300         struct expression *one, *two;
 301         char *one_name, *two_name;
 302         int comparison;
 303         const char *str;
 304
 305         one = get_argument_from_call_expr(expr->args, 0);
 306         two = get_argument_from_call_expr(expr->args, 1);
 307
 308         comparison = get_comparison(one, two);
 309         if (!comparison)
 310                 str = "<nothing>";
 311         else
 312                 str = show_special(comparison);
 313
 314         one_name = expr_to_var(one);
 315         two_name = expr_to_var(two);
 316
 317         sm_msg("%s %s %s", one_name, str, two_name);
 318
 319         free_string(one_name);
 320         free_string(two_name);
 321 }
 322
 323 static void match_debug_on(const char *fn, struct expression *expr, void *info)
 324 {
 325         option_debug = 1;
 326 }
 327
 328 static void match_debug_off(const char *fn, struct expression *expr, void *info)
 329 {
 330         option_debug = 0;
 331 }
 332
 333 static void match_local_debug_on(const char *fn, struct expression *expr, void *info)
 334 {
 335         local_debug = 1;
 336 }
 337
 338 static void match_local_debug_off(const char *fn, struct expression *expr, void *info)
 339 {
 340         local_debug = 0;
 341 }
 342
 343 static void match_debug_implied_on(const char *fn, struct expression *expr, void *info)
 344 {
 345         option_debug_implied = 1;
 346 }
 347
 348 static void match_debug_implied_off(const char *fn, struct expression *expr, void *info)
 349 {
 350         option_debug_implied = 0;
 351 }
 352
 353 void check_debug(int id)
 354 {
 355         my_id = id;
 356         add_function_hook("__smatch_all_values", &match_all_values, NULL);
 357         add_function_hook("__smatch_state", &match_state, NULL);
 358         add_function_hook("__smatch_value", &match_print_value, NULL);
 359         add_function_hook("__smatch_implied", &match_print_implied, NULL);
 360         add_function_hook("__smatch_implied_min", &match_print_implied_min, NULL);
 361         add_function_hook("__smatch_implied_max", &match_print_implied_max, NULL);
 362         add_function_hook("__smatch_hard_max", &match_print_hard_max, NULL);
 363         add_function_hook("__smatch_fuzzy_max", &match_print_fuzzy_max, NULL);
 364         add_function_hook("__smatch_absolute_min", &match_print_absolute_min, NULL);
 365         add_function_hook("__smatch_absolute_max", &match_print_absolute_max, NULL);
 366         add_function_hook("__smatch_sval_info", &match_sval_info, NULL);
 367         add_function_hook("__smatch_possible", &match_possible, NULL);
 368         add_function_hook("__smatch_cur_slist", &match_cur_slist, NULL);
 369         add_function_hook("__smatch_buf_size", &match_buf_size, NULL);
 370         add_function_hook("__smatch_note", &match_note, NULL);
 371         add_function_hook("__smatch_dump_related", &match_dump_related, NULL);
 372         add_function_hook("__smatch_compare", &match_compare, NULL);
 373         add_function_hook("__smatch_debug_on", &match_debug_on, NULL);
 374         add_function_hook("__smatch_debug_off", &match_debug_off, NULL);
 375         add_function_hook("__smatch_local_debug_on", &match_local_debug_on, NULL);
 376         add_function_hook("__smatch_local_debug_off", &match_local_debug_off, NULL);
 377         add_function_hook("__smatch_debug_implied_on", &match_debug_implied_on, NULL);
 378         add_function_hook("__smatch_debug_implied_off", &match_debug_implied_off, NULL);
 379 }