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         long long val;
  68         char *name;
  69
  70         arg = get_argument_from_call_expr(expr->args, 0);
  71         if (!get_implied_min(arg, &val))
  72                 val = whole_range.min;
  73
  74         name = get_variable_from_expr_complex(arg, NULL);
  75         sm_msg("implied min: %s = %lld", name, val);
  76         free_string(name);
  77 }
  78
  79 static void match_print_implied_max(const char *fn, struct expression *expr, void *info)
  80 {
  81         struct expression *arg;
  82         long long val;
  83         char *name;
  84
  85         arg = get_argument_from_call_expr(expr->args, 0);
  86         if (!get_implied_max(arg, &val))
  87                 val = whole_range.max;
  88
  89         name = get_variable_from_expr_complex(arg, NULL);
  90         sm_msg("implied max: %s = %lld", name, val);
  91         free_string(name);
  92 }
  93
  94 static void print_possible(struct sm_state *sm)
  95 {
  96         struct sm_state *tmp;
  97
  98         sm_msg("Possible values for %s", sm->name);
  99         FOR_EACH_PTR(sm->possible, tmp) {
 100                 printf("%s\n", tmp->state->name);
 101         } END_FOR_EACH_PTR(tmp);
 102         sm_msg("===");
 103 }
 104
 105 static void match_possible(const char *fn, struct expression *expr, void *info)
 106 {
 107         struct state_list *slist;
 108         struct sm_state *tmp;
 109         struct expression *arg_expr;
 110
 111         arg_expr = get_argument_from_call_expr(expr->args, 0);
 112         if (arg_expr->type != EXPR_STRING) {
 113                 sm_msg("error:  the argument to %s is supposed to be a string literal", fn);
 114                 return;
 115         }
 116
 117         slist = get_all_states(SMATCH_EXTRA);
 118         FOR_EACH_PTR(slist, tmp) {
 119                 if (!strcmp(tmp->name, arg_expr->string->data))
 120                         print_possible(tmp);
 121         } END_FOR_EACH_PTR(tmp);
 122         free_slist(&slist);
 123 }
 124
 125 static void match_note(const char *fn, struct expression *expr, void *info)
 126 {
 127         struct expression *arg_expr;
 128
 129         arg_expr = get_argument_from_call_expr(expr->args, 0);
 130         if (arg_expr->type != EXPR_STRING) {
 131                 sm_msg("error:  the argument to %s is supposed to be a string literal", fn);
 132                 return;
 133         }
 134         sm_msg("%s", arg_expr->string->data);
 135 }
 136
 137 static void print_related(struct sm_state *sm)
 138 {
 139         struct relation *rel;
 140
 141         if (!estate_related(sm->state))
 142                 return;
 143
 144         sm_prefix();
 145         sm_printf("%s: ", sm->name);
 146         FOR_EACH_PTR(estate_related(sm->state), rel) {
 147                 sm_printf("%s %s ", show_special(rel->op), rel->name);
 148         } END_FOR_EACH_PTR(rel);
 149         sm_printf("\n");
 150 }
 151
 152 static void match_dump_related(const char *fn, struct expression *expr, void *info)
 153 {
 154         struct state_list *slist;
 155         struct sm_state *tmp;
 156
 157         slist = get_all_states(SMATCH_EXTRA);
 158         FOR_EACH_PTR(slist, tmp) {
 159                 print_related(tmp);
 160         } END_FOR_EACH_PTR(tmp);
 161         free_slist(&slist);
 162 }
 163
 164 static void match_debug_on(const char *fn, struct expression *expr, void *info)
 165 {
 166         option_debug = 1;
 167 }
 168
 169 static void match_debug_off(const char *fn, struct expression *expr, void *info)
 170 {
 171         option_debug = 0;
 172 }
 173 void check_debug(int id)
 174 {
 175         my_id = id;
 176         add_function_hook("__smatch_all_values", &match_all_values, NULL);
 177         add_function_hook("__smatch_value", &match_print_value, NULL);
 178         add_function_hook("__smatch_implied", &match_print_implied, NULL);
 179         add_function_hook("__smatch_implied_min", &match_print_implied_min, NULL);
 180         add_function_hook("__smatch_implied_max", &match_print_implied_max, NULL);
 181         add_function_hook("__smatch_possible", &match_possible, NULL);
 182         add_function_hook("__smatch_cur_slist", &match_cur_slist, NULL);
 183         add_function_hook("__smatch_note", &match_note, NULL);
 184         add_function_hook("__smatch_dump_related", &match_dump_related, NULL);
 185         add_function_hook("__smatch_debug_on", &match_debug_on, NULL);
 186         add_function_hook("__smatch_debug_off", &match_debug_off, NULL);
 187 }