smatch_param_filter.c

   1 /*
   2  * sparse/smatch_param_filter.c
   3  *
   4  * Copyright (C) 2012 Oracle.
   5  *
   6  * Licensed under the Open Software License version 1.1
   7  *
   8  */
   9
  10 #include "smatch.h"
  11 #include "smatch_extra.h"
  12 #include "smatch_slist.h"
  13
  14 static int my_id;
  15
  16 STATE(modified);
  17 STATE(original);
  18
  19 static struct state_list *start_states;
  20 static void save_start_states(struct statement *stmt)
  21 {
  22         start_states = get_all_states(SMATCH_EXTRA);
  23 }
  24
  25 static void match_end_func(void)
  26 {
  27         free_slist(&start_states);
  28 }
  29
  30 static struct smatch_state *unmatched_state(struct sm_state *sm)
  31 {
  32         return &original;
  33 }
  34
  35 static void extra_mod_hook(const char *name, struct symbol *sym, struct smatch_state *state)
  36 {
  37         int param;
  38
  39         param = get_param_num_from_sym(sym);
  40         if (param < 0)
  41                 return;
  42
  43         set_state(my_id, name, sym, &modified);
  44 }
  45
  46 static const char *get_param_name(struct sm_state *sm)
  47 {
  48         char *param_name;
  49         int name_len;
  50         static char buf[256];
  51
  52         if (!sm->sym->ident)
  53                 return NULL;
  54
  55         param_name = sm->sym->ident->name;
  56         name_len = strlen(param_name);
  57
  58         if (strcmp(sm->name, param_name) == 0) {
  59                 return "$$";
  60         } else if (sm->name[name_len] == '-' && /* check for '-' from "->" */
  61             strncmp(sm->name, param_name, name_len) == 0) {
  62                 snprintf(buf, sizeof(buf), "$$%s", sm->name + name_len);
  63                 return buf;
  64         } else if (sm->name[0] == '*' && strcmp(sm->name + 1, param_name) == 0) {
  65                 return "*$$";
  66         }
  67         return NULL;
  68 }
  69
  70 static char *get_orig_rl(struct sm_state *sm)
  71 {
  72         struct range_list *ret = NULL;
  73         struct sm_state *tmp;
  74         struct smatch_state *extra;
  75
  76         FOR_EACH_PTR(sm->possible, tmp) {
  77                 if (tmp->state != &original)
  78                         continue;
  79                 extra = get_state_slist(tmp->pool, SMATCH_EXTRA, tmp->name, tmp->sym);
  80                 if (!extra) {
  81                         sm_msg("debug: no value found in pool %p", tmp->pool);
  82                         return NULL;
  83                 }
  84                 ret = rl_union(ret, estate_rl(extra));
  85         } END_FOR_EACH_PTR(tmp);
  86         return show_rl(ret);
  87 }
  88
  89 static void print_one_mod_param(int return_id, char *return_ranges,
  90                         int param, struct sm_state *sm, struct state_list *slist)
  91 {
  92         const char *param_name;
  93         char *filter;
  94
  95         param_name = get_param_name(sm);
  96         if (!param_name)
  97                 return;
  98         filter = get_orig_rl(sm);
  99         if (!filter)
 100                 return;
 101
 102         sm_msg("info: return_param_filter %d %d '%s' '%s' '%s' %s",
 103                return_id, param, return_ranges,
 104                param_name, filter, global_static());
 105 }
 106
 107 static void print_one_extra_param(int return_id, char *return_ranges,
 108                         int param, struct sm_state *sm, struct state_list *slist)
 109 {
 110         struct smatch_state *old;
 111         const char *param_name;
 112
 113         old = get_state_slist(start_states, SMATCH_EXTRA, sm->name, sm->sym);
 114         if (old && estates_equiv(old, sm->state))
 115                 return;
 116
 117         param_name = get_param_name(sm);
 118         if (!param_name)
 119                 return;
 120
 121         sm_msg("info: return_param_filter %d %d '%s' '%s' '%s' %s",
 122                return_id, param, return_ranges,
 123                param_name, show_rl(estate_rl(sm->state)), global_static());
 124 }
 125
 126 static void print_return_value_param(int return_id, char *return_ranges, struct expression *expr, struct state_list *slist)
 127 {
 128         struct state_list *extra_slist;
 129         struct sm_state *tmp;
 130         struct sm_state *sm;
 131         int param;
 132
 133         extra_slist = get_all_states_slist(SMATCH_EXTRA, slist);
 134
 135         FOR_EACH_PTR(extra_slist, tmp) {
 136                 param = get_param_num_from_sym(tmp->sym);
 137                 if (param < 0)
 138                         continue;
 139                 /*
 140                  * skip the parameter itself because that's handled by
 141                  * smatch_param_limit.c.
 142                  */
 143                 if (tmp->sym->ident && strcmp(tmp->sym->ident->name, tmp->name) == 0)
 144                         continue;
 145
 146                 sm = get_sm_state_slist(slist, my_id, tmp->name, tmp->sym);
 147                 if (sm)
 148                         print_one_mod_param(return_id, return_ranges, param, sm, slist);
 149                 else
 150                         print_one_extra_param(return_id, return_ranges, param, tmp, slist);
 151         } END_FOR_EACH_PTR(tmp);
 152
 153         free_slist(&extra_slist);
 154 }
 155
 156 void register_param_filter(int id)
 157 {
 158         if (!option_info)
 159                 return;
 160
 161         my_id = id;
 162
 163         add_hook(&save_start_states, AFTER_DEF_HOOK);
 164         add_extra_mod_hook(&extra_mod_hook);
 165         add_unmatched_state_hook(my_id, &unmatched_state);
 166         add_returned_state_callback(&print_return_value_param);
 167         add_hook(&match_end_func, END_FUNC_HOOK);
 168 }
 169