smatch_param_limit.c

   1 /*
   2  * sparse/smatch_param_limit.c
   3  *
   4  * Copyright (C) 2012 Oracle.
   5  *
   6  * Licensed under the Open Software License version 1.1
   7  *
   8  */
   9
  10 #include "scope.h"
  11 #include "smatch.h"
  12 #include "smatch_extra.h"
  13
  14 static int orig_id;
  15 static int modify_id;
  16 static int side_effects;
  17
  18 STATE(modified);
  19
  20 static struct smatch_state *unmatched_state(struct sm_state *sm)
  21 {
  22         return extra_undefined(estate_type(sm->state));
  23 }
  24
  25 int was_modified_sym(struct symbol *sym)
  26 {
  27         if (!side_effects)
  28                 return 0;
  29         if (!sym || !sym->ident)
  30                 return 1;  /* safer to say it was modified? */
  31         if (get_state(modify_id, sym->ident->name, sym))
  32                 return 1;
  33         return 0;
  34 }
  35
  36 static int is_local(struct symbol *sym)
  37 {
  38         if (!sym->scope || !sym->scope->token)
  39                 return 0;
  40         return 1;
  41 }
  42
  43 static void check_expr(struct expression *expr)
  44 {
  45         struct smatch_state *state;
  46         struct symbol *sym;
  47         char *name;
  48
  49         name = get_variable_from_expr_complex(expr, &sym);
  50         if (!sym) {
  51                 side_effects = 1;
  52                 goto free;
  53         }
  54
  55         if (!is_local(sym))
  56                 side_effects = 1;
  57
  58         /*
  59          * Pointers are so tricky to handle just bail.
  60          */
  61         if (get_real_base_type(sym)->type == SYM_PTR)
  62                 side_effects = 1;
  63
  64         /*
  65          * TODO: it should only do this if we modify something that's not on the
  66          * stack.
  67          */
  68         if (get_param_num_from_sym(sym) >= 0) {
  69                 side_effects = 1;
  70                 if (!get_state_expr(orig_id, expr)) {
  71                         state = get_implied_estate(expr);
  72                         set_state_expr(orig_id, expr, state);
  73                 }
  74         }
  75
  76         set_state_expr(modify_id, expr, &modified);
  77 free:
  78         free_string(name);
  79 }
  80
  81 static void match_assign(struct expression *expr)
  82 {
  83         check_expr(expr->left);
  84 }
  85
  86 static void unop_expr(struct expression *expr)
  87 {
  88         if (expr->op != SPECIAL_DECREMENT && expr->op != SPECIAL_INCREMENT)
  89                 return;
  90
  91         expr = strip_expr(expr->unop);
  92         check_expr(expr);
  93 }
  94
  95 static int no_effect_func;
  96 static int db_no_effect_func(void *unused, int argc, char **argv, char **azColName)
  97 {
  98         no_effect_func = 1;
  99         return 0;
 100 }
 101
 102 static int is_no_side_effect_func(struct expression *fn)
 103 {
 104         static char sql_filter[1024];
 105
 106         if (fn->type != EXPR_SYMBOL || !fn->symbol)
 107                 return 0;
 108
 109         if (fn->symbol->ctype.modifiers & MOD_STATIC) {
 110                 snprintf(sql_filter, 1024, "file = '%s' and function = '%s';",
 111                          get_filename(), fn->symbol->ident->name);
 112         } else {
 113                 snprintf(sql_filter, 1024, "function = '%s' and static = 0;",
 114                          fn->symbol->ident->name);
 115         }
 116
 117         no_effect_func = 0;
 118         run_sql(db_no_effect_func, "select * from no_side_effects where %s", sql_filter);
 119
 120         return no_effect_func;
 121 }
 122
 123 static void match_call(struct expression *expr)
 124 {
 125         struct expression *arg, *tmp;
 126
 127         if (!is_no_side_effect_func(expr->fn))
 128                 side_effects = 1;
 129
 130         FOR_EACH_PTR(expr->args, arg) {
 131                 tmp = strip_expr(arg);
 132                 if (tmp->type != EXPR_PREOP || tmp->op != '&')
 133                         continue;
 134                 tmp = strip_expr(tmp->unop);
 135                 check_expr(expr);
 136         } END_FOR_EACH_PTR(arg);
 137 }
 138
 139 static void asm_expr(struct statement *stmt)
 140 {
 141
 142         struct expression *expr;
 143         int state = 0;
 144
 145         FOR_EACH_PTR(stmt->asm_outputs, expr) {
 146                 switch (state) {
 147                 case 0: /* identifier */
 148                 case 1: /* constraint */
 149                         state++;
 150                         continue;
 151                 case 2: /* expression */
 152                         state = 0;
 153                         check_expr(expr);
 154                         continue;
 155                 }
 156         } END_FOR_EACH_PTR(expr);
 157 }
 158
 159 struct smatch_state *get_orig_estate(struct symbol *sym)
 160 {
 161         struct smatch_state *state;
 162
 163         if (!sym->ident || !sym->ident->name)
 164                 return NULL;
 165
 166         state = get_state(orig_id, sym->ident->name, sym);
 167         if (state)
 168                 return state;
 169
 170         return get_state(SMATCH_EXTRA, sym->ident->name, sym);
 171 }
 172
 173 static void print_return_value_param(int return_id, char *return_ranges, struct expression *expr, struct state_list *slist)
 174 {
 175         struct smatch_state *state;
 176         struct symbol *tmp;
 177         int param;
 178
 179         param = -1;
 180         FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, tmp) {
 181                 param++;
 182                 state = get_orig_estate(tmp);
 183                 if (!state)
 184                         continue;
 185                 sm_msg("info: return_limited_param %d %d '%s' '$$' '%s' %s",
 186                        return_id, param, return_ranges,
 187                        state->name, global_static());
 188         } END_FOR_EACH_PTR(tmp);
 189 }
 190
 191 static void match_end_func(struct symbol *sym)
 192 {
 193         if (option_info && !side_effects)
 194                 sm_msg("info: no_side_effects %s", global_static());
 195         side_effects = 0;
 196 }
 197
 198 void register_param_limit(int id)
 199 {
 200         modify_id = id;
 201
 202         add_hook(&match_assign, ASSIGNMENT_HOOK);
 203         add_hook(&unop_expr, OP_HOOK);
 204         add_hook(&match_call, FUNCTION_CALL_HOOK);
 205         add_hook(&asm_expr, ASM_HOOK);
 206         add_hook(&match_end_func, END_FUNC_HOOK);
 207         add_returned_state_callback(&print_return_value_param);
 208 }
 209
 210 void register_param_limit2(int id)
 211 {
 212         orig_id = id;
 213         add_merge_hook(orig_id, &merge_estates);
 214         add_unmatched_state_hook(orig_id, &unmatched_state);
 215 }
 216