check_signed.c

   1 /*
   2  * sparse/check_signed.c
   3  *
   4  * Copyright (C) 2009 Dan Carpenter.
   5  *
   6  * Licensed under the Open Software License version 1.1
   7  *
   8  */
   9
  10 /*
  11  * Check for things which are signed but probably should be unsigned.
  12  *
  13  * Hm...  It seems like at this point in the processing, sparse makes all
  14  * bitfields unsigned.  Which is logical but not what GCC does.
  15  *
  16  */
  17
  18 #include "smatch.h"
  19
  20 static int my_id;
  21
  22 #define RIGHT 0
  23 #define LEFT 1
  24
  25 static int is_unsigned(struct symbol *base_type)
  26 {
  27         if (base_type->ctype.modifiers & MOD_UNSIGNED)
  28                 return 1;
  29         return 0;
  30 }
  31
  32 static void match_assign(struct expression *expr)
  33 {
  34         struct symbol *sym;
  35         long long val;
  36         long long max;
  37         char *name;
  38
  39         sym = get_type(expr->left);
  40         if (!sym) {
  41                 //sm_msg("could not get type");
  42                 return;
  43         }
  44         if (sym->bit_size >= 32) /* max_val limits this */
  45                 return;
  46         if (!get_implied_value(expr->right, &val))
  47                 return;
  48         max = type_max(sym);
  49         if (max && max < val) {
  50                 name = get_variable_from_expr_complex(expr->left, NULL);
  51                 sm_msg("warn: value %lld can't fit into %lld '%s'", val, max, name);
  52                 free_string(name);
  53         }
  54 }
  55
  56 static void match_condition(struct expression *expr)
  57 {
  58         long long known;
  59         struct expression *var = NULL;
  60         struct symbol *type = NULL;
  61         long long max;
  62         int lr;
  63         char *name;
  64
  65         if (expr->type != EXPR_COMPARE)
  66                 return;
  67
  68         if (get_value(expr->left, &known)) {
  69                 lr = RIGHT;
  70                 var = expr->right;
  71         } else if (get_value(expr->right, &known)) {
  72                 lr = LEFT;
  73                 var = expr->left;
  74         } else {
  75                 return;
  76         }
  77
  78         type = get_type(var);
  79         if (!type || type->bit_size >= 32)
  80                 return;
  81
  82         max = type_max(type);
  83         if (!max)
  84                 return;
  85
  86         name = get_variable_from_expr_complex(var, NULL);
  87
  88         if (known < 0) {
  89                 if (is_unsigned(type))
  90                         sm_msg("error: comparing unsigned '%s' to negative", name);
  91                 goto free;
  92         }
  93
  94         if (known == 0) {
  95                 if (!is_unsigned(type))
  96                         goto free;
  97                 if (lr == LEFT) {
  98                         if (expr->op == '<')
  99                                 sm_msg("error: unsigned '%s' cannot be less than 0", name);
 100                         if (expr->op == SPECIAL_LTE)
 101                                 sm_msg("warn: unsigned '%s' cannot be less than 0", name);
 102                 }
 103                 if (lr == RIGHT) {
 104                         if (expr->op == '>')
 105                                 sm_msg("error: unsigned '%s' cannot be less than 0", name);
 106                         if (expr->op == SPECIAL_GTE)
 107                                 sm_msg("warn: unsigned '%s' cannot be less than 0", name);
 108                 }
 109                 goto free;
 110         }
 111
 112         if (max < known) {
 113                 const char *tf = "the same";
 114
 115                 if (expr->op == SPECIAL_EQUAL)
 116                         tf = "false";
 117                 if (expr->op == SPECIAL_NOTEQUAL)
 118                         tf = "true";
 119                 if (lr == LEFT && (expr->op == '<' || expr->op == SPECIAL_LTE))
 120                         tf = "true";
 121                 if (lr == RIGHT && (expr->op == '>' || expr->op == SPECIAL_GTE))
 122                         tf = "false";
 123                 sm_msg("warn: %lld is higher than %lld (max '%s' can be) so this is always %s.",
 124                         known, max, name, tf);
 125         }
 126 free:
 127         free_string(name);
 128 }
 129
 130 void check_signed(int id)
 131 {
 132         my_id = id;
 133
 134         add_hook(&match_assign, ASSIGNMENT_HOOK);
 135         add_hook(&match_condition, CONDITION_HOOK);
 136 }