check_signed.c

   1 /*
   2  * Copyright (C) 2009 Dan Carpenter.
   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 /*
  19  * Check for things which are signed but probably should be unsigned.
  20  *
  21  * Hm...  It seems like at this point in the processing, sparse makes all
  22  * bitfields unsigned.  Which is logical but not what GCC does.
  23  *
  24  */
  25
  26 #include "smatch.h"
  27 #include "smatch_extra.h"
  28
  29 static int my_id;
  30
  31 static void match_assign(struct expression *expr)
  32 {
  33         struct symbol *sym;
  34         sval_t sval;
  35         sval_t max;
  36         sval_t min;
  37         char *left_name, *right_name;
  38
  39         if (__in_fake_assign)
  40                 return;
  41         if (is_fake_var_assign(expr))
  42                 return;
  43         if (expr->op == SPECIAL_AND_ASSIGN || expr->op == SPECIAL_OR_ASSIGN)
  44                 return;
  45
  46         sym = get_type(expr->left);
  47         if (!sym || sym->type != SYM_BASETYPE) {
  48                 //sm_msg("could not get type");
  49                 return;
  50         }
  51         if (type_bits(sym) < 0 || type_bits(sym) >= 32) /* max_val limits this */
  52                 return;
  53         if (!get_implied_value(expr->right, &sval))
  54                 return;
  55         max = sval_type_max(sym);
  56         if (sym != &bool_ctype && sym != &uchar_ctype &&
  57             sval_cmp(max, sval) < 0 &&
  58             !(sval.value < 256 && max.value == 127)) {
  59                 left_name = expr_to_str(expr->left);
  60                 right_name = expr_to_str(expr->right);
  61                 sm_warning("'%s' %s can't fit into %s '%s'",
  62                        right_name, sval_to_numstr(sval), sval_to_numstr(max), left_name);
  63                 free_string(left_name);
  64         }
  65         min = sval_type_min(sym);
  66         if (sval_cmp_t(&llong_ctype, min, sval) > 0) {
  67                 if (min.value == 0 && sval.value == -1) /* assigning -1 to unsigned variables is idiomatic */
  68                         return;
  69                 if (expr->right->type == EXPR_PREOP && expr->right->op == '~')
  70                         return;
  71                 if (expr->op == SPECIAL_SUB_ASSIGN || expr->op == SPECIAL_ADD_ASSIGN)
  72                         return;
  73                 if (sval_positive_bits(sval) == 7)
  74                         return;
  75                 left_name = expr_to_str(expr->left);
  76                 if (min.value == 0) {
  77                         sm_warning("assigning %s to unsigned variable '%s'",
  78                                sval_to_str(sval), left_name);
  79                 } else {
  80                         sm_warning("value %s can't fit into %s '%s'",
  81                                sval_to_str(sval), sval_to_str(min), left_name);
  82                 }
  83                 free_string(left_name);
  84         }
  85 }
  86
  87 static int cap_gt_zero_and_lt(struct expression *expr)
  88 {
  89
  90         struct expression *var = expr->left;
  91         struct expression *tmp;
  92         char *name1 = NULL;
  93         char *name2 = NULL;
  94         sval_t known;
  95         int ret = 0;
  96         int i;
  97
  98         if (!get_value(expr->right, &known) || known.value != 0)
  99                 return 0;
 100
 101         i = 0;
 102         FOR_EACH_PTR_REVERSE(big_expression_stack, tmp) {
 103                 if (!i++)
 104                         continue;
 105                 if (tmp->op == SPECIAL_LOGICAL_AND) {
 106                         struct expression *right = strip_expr(tmp->right);
 107
 108                         if (right->op != '<' &&
 109                             right->op != SPECIAL_UNSIGNED_LT &&
 110                             right->op != SPECIAL_LTE &&
 111                             right->op != SPECIAL_UNSIGNED_LTE)
 112                                 return 0;
 113
 114                         name1 = expr_to_str(var);
 115                         if (!name1)
 116                                 goto free;
 117
 118                         name2 = expr_to_str(right->left);
 119                         if (!name2)
 120                                 goto free;
 121                         if (!strcmp(name1, name2))
 122                                 ret = 1;
 123                         goto free;
 124
 125                 }
 126                 return 0;
 127         } END_FOR_EACH_PTR_REVERSE(tmp);
 128
 129 free:
 130         free_string(name1);
 131         free_string(name2);
 132         return ret;
 133 }
 134
 135 static int cap_lt_zero_or_gt(struct expression *expr)
 136 {
 137
 138         struct expression *var = expr->left;
 139         struct expression *tmp;
 140         char *name1 = NULL;
 141         char *name2 = NULL;
 142         sval_t known;
 143         int ret = 0;
 144         int i;
 145
 146         if (!get_value(expr->right, &known) || known.value != 0)
 147                 return 0;
 148
 149         i = 0;
 150         FOR_EACH_PTR_REVERSE(big_expression_stack, tmp) {
 151                 if (!i++)
 152                         continue;
 153                 if (tmp->op == SPECIAL_LOGICAL_OR) {
 154                         struct expression *right = strip_expr(tmp->right);
 155
 156                         if (right->op != '>' &&
 157                             right->op != SPECIAL_UNSIGNED_GT &&
 158                             right->op != SPECIAL_GTE &&
 159                             right->op != SPECIAL_UNSIGNED_GTE)
 160                                 return 0;
 161
 162                         name1 = expr_to_str(var);
 163                         if (!name1)
 164                                 goto free;
 165
 166                         name2 = expr_to_str(right->left);
 167                         if (!name2)
 168                                 goto free;
 169                         if (!strcmp(name1, name2))
 170                                 ret = 1;
 171                         goto free;
 172
 173                 }
 174                 return 0;
 175         } END_FOR_EACH_PTR_REVERSE(tmp);
 176
 177 free:
 178         free_string(name1);
 179         free_string(name2);
 180         return ret;
 181 }
 182
 183 static int cap_both_sides(struct expression *expr)
 184 {
 185         switch (expr->op) {
 186         case '<':
 187         case SPECIAL_UNSIGNED_LT:
 188         case SPECIAL_LTE:
 189         case SPECIAL_UNSIGNED_LTE:
 190                 return cap_lt_zero_or_gt(expr);
 191         case '>':
 192         case SPECIAL_UNSIGNED_GT:
 193         case SPECIAL_GTE:
 194         case SPECIAL_UNSIGNED_GTE:
 195                 return cap_gt_zero_and_lt(expr);
 196         }
 197         return 0;
 198 }
 199
 200 static int compare_against_macro(struct expression *expr)
 201 {
 202         sval_t known;
 203
 204         if (expr->op != SPECIAL_UNSIGNED_LT)
 205                 return 0;
 206
 207         if (!get_value(expr->right, &known) || known.value != 0)
 208                 return 0;
 209         return !!get_macro_name(expr->right->pos);
 210 }
 211
 212 static bool check_is_ulong_max_recursive(struct expression *expr)
 213 {
 214         sval_t sval;
 215
 216         expr = strip_expr(expr);
 217
 218         if (!get_value(expr, &sval))
 219                 return false;
 220
 221         if (expr->type == EXPR_BINOP) {
 222                 if (check_is_ulong_max_recursive(expr->left))
 223                         return true;
 224                 return false;
 225         }
 226
 227         if (sval_cmp(sval, sval_type_max(&ulong_ctype)) == 0)
 228                 return true;
 229         return false;
 230 }
 231
 232 static bool is_u64_vs_ulongmax(struct expression *expr)
 233 {
 234         struct symbol *left, *right;
 235
 236         if (expr->op != '>' && expr->op != SPECIAL_UNSIGNED_GT)
 237                 return false;
 238         if (!check_is_ulong_max_recursive(expr->right))
 239                 return false;
 240
 241         left = get_type(expr->left);
 242         right = get_type(expr->right);
 243
 244         if (left == right)
 245                 return true;
 246         if (type_positive_bits(left) < type_positive_bits(right))
 247                 return true;
 248
 249         if (type_bits(left) != 64)
 250                 return false;
 251         if (right != &ulong_ctype && right != &uint_ctype)
 252                 return false;
 253
 254         return true;
 255 }
 256
 257 static void match_condition(struct expression *expr)
 258 {
 259         struct symbol *type;
 260         sval_t known;
 261         sval_t min, max;
 262         struct range_list *rl_left_orig, *rl_right_orig;
 263         struct range_list *rl_left, *rl_right;
 264
 265         if (expr->type != EXPR_COMPARE)
 266                 return;
 267
 268         type = get_type(expr);
 269         if (!type)
 270                 return;
 271
 272         /* screw it.  I am writing this to mark yoda code as buggy.
 273          * Valid comparisons between an unsigned and zero are:
 274          * 1) inside a macro.
 275          * 2) foo < LOWER_BOUND where LOWER_BOUND is a macro.
 276          * 3) foo < 0 || foo > X in exactly this format.  No Yoda.
 277          * 4) foo >= 0 && foo < X
 278          */
 279         if (get_macro_name(expr->pos))
 280                 return;
 281         if (compare_against_macro(expr))
 282                 return;
 283         if (cap_both_sides(expr))
 284                 return;
 285
 286         /* check that one and only one side is known */
 287         if (get_value(expr->left, &known)) {
 288                 if (get_value(expr->right, &known))
 289                         return;
 290                 rl_left_orig = alloc_rl(known, known);
 291                 rl_left = cast_rl(type, rl_left_orig);
 292
 293                 min = sval_type_min(get_type(expr->right));
 294                 max = sval_type_max(get_type(expr->right));
 295                 rl_right_orig = alloc_rl(min, max);
 296                 rl_right = cast_rl(type, rl_right_orig);
 297         } else if (get_value(expr->right, &known)) {
 298                 rl_right_orig = alloc_rl(known, known);
 299                 rl_right = cast_rl(type, rl_right_orig);
 300
 301                 min = sval_type_min(get_type(expr->left));
 302                 max = sval_type_max(get_type(expr->left));
 303                 rl_left_orig = alloc_rl(min, max);
 304                 rl_left = cast_rl(type, rl_left_orig);
 305         } else {
 306                 return;
 307         }
 308
 309         if (!possibly_true_rl(rl_left, expr->op, rl_right) &&
 310             !is_u64_vs_ulongmax(expr)) {
 311                 char *name = expr_to_str(expr);
 312
 313                 sm_warning("impossible condition '(%s) => (%s %s %s)'", name,
 314                        show_rl(rl_left), show_special(expr->op),
 315                        show_rl(rl_right));
 316                 free_string(name);
 317         }
 318
 319         if (!possibly_false_rl(rl_left, expr->op, rl_right) &&
 320             !is_unconstant_macro(expr->left) &&
 321             !is_unconstant_macro(expr->right)) {
 322                 char *name = expr_to_str(expr);
 323
 324                 sm_warning("always true condition '(%s) => (%s %s %s)'", name,
 325                        show_rl(rl_left_orig), show_special(expr->op),
 326                        show_rl(rl_right_orig));
 327                 free_string(name);
 328         }
 329 }
 330
 331 void check_signed(int id)
 332 {
 333         my_id = id;
 334
 335         add_hook(&match_assign, ASSIGNMENT_HOOK);
 336         add_hook(&match_condition, CONDITION_HOOK);
 337 }