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 static int my_id;
  15
  16 static void match_all_values(const char *fn, struct expression *expr, void *info)
  17 {
  18         struct state_list *slist;
  19
  20         slist = get_all_states(SMATCH_EXTRA);
  21         __print_slist(slist);
  22         free_slist(&slist);
  23 }
  24
  25 static void match_cur_slist(const char *fn, struct expression *expr, void *info)
  26 {
  27         __print_cur_slist();
  28 }
  29
  30 static void match_print_value(const char *fn, struct expression *expr, void *info)
  31 {
  32         struct state_list *slist;
  33         struct sm_state *tmp;
  34         struct expression *arg_expr;
  35
  36         arg_expr = get_argument_from_call_expr(expr->args, 0);
  37         if (arg_expr->type != EXPR_STRING) {
  38                 sm_msg("error:  the argument to %s is supposed to be a string literal", fn);
  39                 return;
  40         }
  41
  42         slist = get_all_states(SMATCH_EXTRA);
  43         FOR_EACH_PTR(slist, tmp) {
  44                 if (!strcmp(tmp->name, arg_expr->string->data))
  45                         sm_msg("%s = %s", tmp->name, tmp->state->name);
  46         } END_FOR_EACH_PTR(tmp);
  47         free_slist(&slist);
  48 }
  49
  50 static void match_print_implied(const char *fn, struct expression *expr, void *info)
  51 {
  52         struct expression *arg;
  53         struct range_list *rl = NULL;
  54         char *name;
  55
  56         arg = get_argument_from_call_expr(expr->args, 0);
  57         get_implied_range_list(arg, &rl);
  58
  59         name = get_variable_from_expr_complex(arg, NULL);
  60         sm_msg("implied: %s = '%s'", name, show_ranges(rl));
  61         free_string(name);
  62 }
  63
  64 static void match_print_implied_min(const char *fn, struct expression *expr, void *info)
  65 {
  66         struct expression *arg;
  67         sval_t sval;
  68         char *name;
  69
  70         arg = get_argument_from_call_expr(expr->args, 0);
  71         name = get_variable_from_expr_complex(arg, NULL);
  72
  73         if (get_implied_min(arg, &sval))
  74                 sm_msg("implied min: %s = %s", name, sval_to_str(sval));
  75         else
  76                 sm_msg("implied min: %s = <unknown>", name);
  77
  78         free_string(name);
  79 }
  80
  81 static void match_print_implied_max(const char *fn, struct expression *expr, void *info)
  82 {
  83         struct expression *arg;
  84         sval_t sval;
  85         char *name;
  86
  87         arg = get_argument_from_call_expr(expr->args, 0);
  88         name = get_variable_from_expr_complex(arg, NULL);
  89
  90         if (get_implied_max(arg, &sval))
  91                 sm_msg("implied max: %s = %s", name, sval_to_str(sval));
  92         else
  93                 sm_msg("implied max: %s = <unknown>", name);
  94
  95         free_string(name);
  96 }
  97
  98 static void match_print_hard_max(const char *fn, struct expression *expr, void *info)
  99 {
 100         struct expression *arg;
 101         sval_t sval;
 102         char *name;
 103
 104         arg = get_argument_from_call_expr(expr->args, 0);
 105         name = get_variable_from_expr_complex(arg, NULL);
 106
 107         if (get_hard_max(arg, &sval))
 108                 sm_msg("hard max: %s = %s", name, sval_to_str(sval));
 109         else
 110                 sm_msg("hard max: %s = <unknown>", name);
 111
 112         free_string(name);
 113 }
 114
 115 static void match_print_fuzzy_max(const char *fn, struct expression *expr, void *info)
 116 {
 117         struct expression *arg;
 118         sval_t sval;
 119         char *name;
 120
 121         arg = get_argument_from_call_expr(expr->args, 0);
 122         name = get_variable_from_expr_complex(arg, NULL);
 123
 124         if (get_fuzzy_max(arg, &sval))
 125                 sm_msg("fuzzy max: %s = %s", name, sval_to_str(sval));
 126         else
 127                 sm_msg("fuzzy max: %s = <unknown>", name);
 128
 129         free_string(name);
 130 }
 131
 132 static void match_print_absolute_min(const char *fn, struct expression *expr, void *info)
 133 {
 134         struct expression *arg;
 135         sval_t sval;
 136         char *name;
 137
 138         arg = get_argument_from_call_expr(expr->args, 0);
 139         name = get_variable_from_expr_complex(arg, NULL);
 140
 141         if (get_absolute_min(arg, &sval))
 142                 sm_msg("absolute min: %s = %s", name, sval_to_str(sval));
 143         else
 144                 sm_msg("absolute min: %s = <unknown>", name);
 145
 146         free_string(name);
 147 }
 148
 149 static void match_print_absolute_max(const char *fn, struct expression *expr, void *info)
 150 {
 151         struct expression *arg;
 152         sval_t sval;
 153         char *name;
 154
 155         arg = get_argument_from_call_expr(expr->args, 0);
 156         get_absolute_max(arg, &sval);
 157
 158         name = get_variable_from_expr_complex(arg, NULL);
 159         sm_msg("absolute max: %s = %s", name, sval_to_str(sval));
 160         free_string(name);
 161 }
 162
 163 static void match_sval_info(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 = get_variable_from_expr_complex(arg, NULL);
 171
 172         if (!get_implied_value(arg, &sval)) {
 173                 sm_msg("no sval for '%s'", name);
 174                 goto free;
 175         }
 176
 177         sm_msg("implied: %s %c%d ->value = %llx", name, sval_unsigned(sval) ? 'u' : 's', sval_bits(sval), sval.value);
 178 free:
 179         free_string(name);
 180 }
 181
 182 static void print_possible(struct sm_state *sm)
 183 {
 184         struct sm_state *tmp;
 185
 186         sm_msg("Possible values for %s", sm->name);
 187         FOR_EACH_PTR(sm->possible, tmp) {
 188                 printf("%s\n", tmp->state->name);
 189         } END_FOR_EACH_PTR(tmp);
 190         sm_msg("===");
 191 }
 192
 193 static void match_possible(const char *fn, struct expression *expr, void *info)
 194 {
 195         struct state_list *slist;
 196         struct sm_state *tmp;
 197         struct expression *arg_expr;
 198
 199         arg_expr = get_argument_from_call_expr(expr->args, 0);
 200         if (arg_expr->type != EXPR_STRING) {
 201                 sm_msg("error:  the argument to %s is supposed to be a string literal", fn);
 202                 return;
 203         }
 204
 205         slist = get_all_states(SMATCH_EXTRA);
 206         FOR_EACH_PTR(slist, tmp) {
 207                 if (!strcmp(tmp->name, arg_expr->string->data))
 208                         print_possible(tmp);
 209         } END_FOR_EACH_PTR(tmp);
 210         free_slist(&slist);
 211 }
 212
 213 static void match_buf_size(const char *fn, struct expression *expr, void *info)
 214 {
 215         struct expression *arg;
 216         int elements, bytes;
 217         char *name;
 218
 219         arg = get_argument_from_call_expr(expr->args, 0);
 220         elements = get_array_size(arg);
 221         bytes = get_array_size_bytes(arg);
 222
 223         name = get_variable_from_expr_complex(arg, NULL);
 224         sm_msg("buf size: '%s' %d elements, %d bytes", name, elements, bytes);
 225         free_string(name);
 226 }
 227
 228 static void match_note(const char *fn, struct expression *expr, void *info)
 229 {
 230         struct expression *arg_expr;
 231
 232         arg_expr = get_argument_from_call_expr(expr->args, 0);
 233         if (arg_expr->type != EXPR_STRING) {
 234                 sm_msg("error:  the argument to %s is supposed to be a string literal", fn);
 235                 return;
 236         }
 237         sm_msg("%s", arg_expr->string->data);
 238 }
 239
 240 static void print_related(struct sm_state *sm)
 241 {
 242         struct relation *rel;
 243
 244         if (!estate_related(sm->state))
 245                 return;
 246
 247         sm_prefix();
 248         sm_printf("%s: ", sm->name);
 249         FOR_EACH_PTR(estate_related(sm->state), rel) {
 250                 sm_printf("%s %s ", show_special(rel->op), rel->name);
 251         } END_FOR_EACH_PTR(rel);
 252         sm_printf("\n");
 253 }
 254
 255 static void match_dump_related(const char *fn, struct expression *expr, void *info)
 256 {
 257         struct state_list *slist;
 258         struct sm_state *tmp;
 259
 260         slist = get_all_states(SMATCH_EXTRA);
 261         FOR_EACH_PTR(slist, tmp) {
 262                 print_related(tmp);
 263         } END_FOR_EACH_PTR(tmp);
 264         free_slist(&slist);
 265 }
 266
 267 static void match_debug_on(const char *fn, struct expression *expr, void *info)
 268 {
 269         option_debug = 1;
 270 }
 271
 272 static void match_debug_off(const char *fn, struct expression *expr, void *info)
 273 {
 274         option_debug = 0;
 275 }
 276
 277 void check_debug(int id)
 278 {
 279         my_id = id;
 280         add_function_hook("__smatch_all_values", &match_all_values, NULL);
 281         add_function_hook("__smatch_value", &match_print_value, NULL);
 282         add_function_hook("__smatch_implied", &match_print_implied, NULL);
 283         add_function_hook("__smatch_implied_min", &match_print_implied_min, NULL);
 284         add_function_hook("__smatch_implied_max", &match_print_implied_max, NULL);
 285         add_function_hook("__smatch_hard_max", &match_print_hard_max, NULL);
 286         add_function_hook("__smatch_fuzzy_max", &match_print_fuzzy_max, NULL);
 287         add_function_hook("__smatch_absolute_min", &match_print_absolute_min, NULL);
 288         add_function_hook("__smatch_absolute_max", &match_print_absolute_max, NULL);
 289         add_function_hook("__smatch_sval_info", &match_sval_info, NULL);
 290         add_function_hook("__smatch_possible", &match_possible, NULL);
 291         add_function_hook("__smatch_cur_slist", &match_cur_slist, NULL);
 292         add_function_hook("__smatch_buf_size", &match_buf_size, NULL);
 293         add_function_hook("__smatch_note", &match_note, NULL);
 294         add_function_hook("__smatch_dump_related", &match_dump_related, NULL);
 295         add_function_hook("__smatch_debug_on", &match_debug_on, NULL);
 296         add_function_hook("__smatch_debug_off", &match_debug_off, NULL);
 297 }