check_double_checking.c

   1 /*
   2  * Copyright (C) 2014 Oracle.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
  16  */
  17
  18 #define _GNU_SOURCE
  19 #include <string.h>
  20 #include "smatch.h"
  21 #include "smatch_slist.h"
  22
  23 static int my_id;
  24
  25 STATE(checked);
  26 STATE(modified);
  27
  28 struct stree *to_check;
  29
  30 static struct statement *get_cur_stmt(void)
  31 {
  32         return last_ptr_list((struct ptr_list *)big_statement_stack);
  33 }
  34
  35 static void set_modified(struct sm_state *sm, struct expression *mod_expr)
  36 {
  37         set_state(my_id, sm->name, sm->sym, &modified);
  38 }
  39
  40 static struct expression *strip_condition(struct expression *expr)
  41 {
  42         expr = strip_expr(expr);
  43
  44         if (expr->type == EXPR_PREOP && expr->op == '!')
  45                 return strip_condition(expr->unop);
  46
  47         if (expr->type == EXPR_COMPARE &&
  48             (expr->op == SPECIAL_EQUAL ||
  49              expr->op == SPECIAL_NOTEQUAL)) {
  50                 if (is_zero(expr->left))
  51                         return strip_condition(expr->right);
  52                 if (is_zero(expr->right))
  53                         return strip_condition(expr->left);
  54         }
  55
  56         return expr;
  57 }
  58
  59 static int conditions_match(struct expression *cond, struct expression *prev)
  60 {
  61         prev = strip_condition(prev);
  62
  63         if (prev == cond)
  64                 return 1;
  65
  66         if (prev->type == EXPR_LOGICAL) {
  67                 if (conditions_match(cond, prev->left) ||
  68                     conditions_match(cond, prev->right))
  69                         return 1;
  70         }
  71
  72         return 0;
  73 }
  74
  75 /*
  76  * People like to do "if (foo) { ... } else if (!foo) { ... }".  Don't
  77  * complain when they do that even though it is nonsense.
  78  */
  79 static int is_obvious_else(struct expression *cond)
  80 {
  81         struct statement *parent;
  82         struct expression *prev;
  83
  84         if (!get_cur_stmt())
  85                 return 0;
  86         parent = get_cur_stmt()->parent;
  87         if (!parent)
  88                 return 0;
  89
  90         if (parent->type != STMT_IF)
  91                 return 0;
  92
  93         if (!parent->if_false)
  94                 return 0;
  95         if (parent->if_false != get_cur_stmt())
  96                 return 0;
  97
  98         prev = strip_condition(parent->if_conditional);
  99
 100         return conditions_match(cond, prev);
 101 }
 102
 103 static int name_means_synchronize(const char *name)
 104 {
 105         if (!name)
 106                 return 0;
 107
 108         if (strcasestr(name, "wait"))
 109                 return 1;
 110         if (strcasestr(name, "down"))
 111                 return 1;
 112         if (strcasestr(name, "lock") && !strcasestr(name, "unlock"))
 113                 return 1;
 114         if (strcasestr(name, "delay"))
 115                 return 1;
 116         if (strcasestr(name, "schedule"))
 117                 return 1;
 118         if (strcmp(name, "smp_rmb") == 0)
 119                 return 1;
 120         if (strcmp(name, "mb") == 0)
 121                 return 1;
 122         if (strcmp(name, "barrier") == 0)
 123                 return 1;
 124         return 0;
 125 }
 126
 127 static int previous_statement_was_synchronize(void)
 128 {
 129         struct statement *stmt;
 130         struct position pos;
 131         struct position prev_pos;
 132         char *ident;
 133
 134         if (__prev_stmt) {
 135                 prev_pos = __prev_stmt->pos;
 136                 prev_pos.line -= 3;
 137         } else {
 138                 prev_pos = __cur_stmt->pos;
 139                 prev_pos.line -= 5;
 140         }
 141
 142         FOR_EACH_PTR_REVERSE(big_statement_stack, stmt) {
 143                 if (stmt->pos.line < prev_pos.line)
 144                         return 0;
 145                 pos = stmt->pos;
 146                 ident = get_macro_name(pos);
 147                 if (name_means_synchronize(ident))
 148                         return 1;
 149                 ident = pos_ident(pos);
 150                 if (!ident)
 151                         continue;
 152                 if (strcmp(ident, "if") == 0) {
 153                         pos.pos += 4;
 154                         ident = pos_ident(pos);
 155                         if (!ident)
 156                                 continue;
 157                 }
 158                 if (name_means_synchronize(ident))
 159                         return 1;
 160         } END_FOR_EACH_PTR_REVERSE(stmt);
 161         return 0;
 162 }
 163
 164 static void match_condition(struct expression *expr)
 165 {
 166         struct smatch_state *state;
 167         sval_t dummy;
 168         char *name;
 169
 170         if (inside_loop())
 171                 return;
 172
 173         if (get_value(expr, &dummy))
 174                 return;
 175
 176         if (get_macro_name(expr->pos))
 177                 return;
 178
 179         state = get_stored_condition(expr);
 180         if (!state || !state->data)
 181                 return;
 182         if (get_macro_name(((struct expression *)state->data)->pos))
 183                 return;
 184
 185         /*
 186          * we allow double checking for NULL because people do this all the time
 187          * and trying to stop them is a losers' battle.
 188          */
 189         if (is_pointer(expr) && implied_condition_true(expr))
 190                 return;
 191
 192         if (definitely_inside_loop()) {
 193                 struct symbol *sym;
 194
 195                 if (__inline_fn)
 196                         return;
 197
 198                 name = expr_to_var_sym(expr, &sym);
 199                 if (!name)
 200                         return;
 201                 set_state_expr(my_id, expr, &checked);
 202                 set_state_stree(&to_check, my_id, name, sym, &checked);
 203                 free_string(name);
 204                 return;
 205         }
 206
 207         if (is_obvious_else(state->data))
 208                 return;
 209
 210         /*
 211          * It's common to test something, then take a lock and test if it is
 212          * still true.
 213          */
 214         if (previous_statement_was_synchronize())
 215                 return;
 216
 217         name = expr_to_str(expr);
 218         sm_msg("warn: we tested '%s' before and it was '%s'", name, state->name);
 219         free_string(name);
 220 }
 221
 222 int get_check_line(struct sm_state *sm)
 223 {
 224         struct sm_state *tmp;
 225
 226         FOR_EACH_PTR(sm->possible, tmp) {
 227                 if (tmp->state == &checked)
 228                         return tmp->line;
 229         } END_FOR_EACH_PTR(tmp);
 230
 231         return get_lineno();
 232 }
 233
 234 static void after_loop(struct statement *stmt)
 235 {
 236         struct sm_state *check, *sm;
 237
 238         if (!stmt || stmt->type != STMT_ITERATOR)
 239                 return;
 240         if (definitely_inside_loop())
 241                 return;
 242         if (__inline_fn)
 243                 return;
 244
 245         FOR_EACH_SM(to_check, check) {
 246                 continue;
 247                 sm = get_sm_state(my_id, check->name, check->sym);
 248                 continue;
 249                 if (!sm)
 250                         continue;
 251                 if (slist_has_state(sm->possible, &modified))
 252                         continue;
 253
 254                 sm_printf("%s:%d %s() ", get_filename(), get_check_line(sm), get_function());
 255                 sm_printf("warn: we tested '%s' already\n", check->name);
 256         } END_FOR_EACH_SM(check);
 257
 258         free_stree(&to_check);
 259 }
 260
 261 static void match_func_end(struct symbol *sym)
 262 {
 263         if (__inline_fn)
 264                 return;
 265         if (to_check)
 266                 sm_msg("debug: odd...  found an function without an end.");
 267         free_stree(&to_check);
 268 }
 269
 270 void check_double_checking(int id)
 271 {
 272         my_id = id;
 273
 274         if (!option_spammy)
 275                 return;
 276
 277         add_hook(&match_condition, CONDITION_HOOK);
 278         add_modification_hook(my_id, &set_modified);
 279         add_hook(after_loop, STMT_HOOK_AFTER);
 280         add_hook(&match_func_end, AFTER_FUNC_HOOK);
 281 }