check_precedence.c

   1 /*
   2  * sparse/check_precedence.c
   3  *
   4  * Copyright (C) 2010 Dan Carpenter.
   5  *
   6  * Licensed under the Open Software License version 1.1
   7  *
   8  */
   9
  10 #include "smatch.h"
  11
  12 static int my_id;
  13
  14 static int is_bool(struct expression *expr)
  15 {
  16         struct symbol *type;
  17
  18         type = get_type(expr);
  19         if (!type)
  20                 return 0;
  21         if (type->bit_size == 1 && type->ctype.modifiers & MOD_UNSIGNED)
  22                 return 1;
  23         return 0;
  24 }
  25
  26 static int is_bool_from_context(struct expression *expr)
  27 {
  28         long long val;
  29
  30         if (!get_implied_max(expr, &val) || val > 1)
  31                 return 0;
  32         if (!get_implied_min(expr, &val) || val < 0)
  33                 return 0;
  34         return 1;
  35 }
  36
  37 static int is_bool_op(struct expression *expr)
  38 {
  39         expr = strip_expr(expr);
  40
  41         if (expr->type == EXPR_PREOP && expr->op == '!')
  42                 return 1;
  43         if (expr->type == EXPR_COMPARE)
  44                 return 1;
  45         if (expr->type == EXPR_LOGICAL)
  46                 return 1;
  47         return is_bool(expr);
  48 }
  49
  50 static void match_condition(struct expression *expr)
  51 {
  52         int print = 0;
  53
  54         if (expr->type == EXPR_COMPARE) {
  55                 if (expr->left->type == EXPR_COMPARE || expr->right->type == EXPR_COMPARE)
  56                         print = 1;
  57                 if (expr->left->op == '!') {
  58                         if (expr->left->type == EXPR_PREOP && expr->left->unop->op == '!')
  59                                 return;
  60                         if (expr->right->op == '!')
  61                                 return;
  62                         if (is_bool(expr->right))
  63                                 return;
  64                         if (is_bool(expr->left->unop))
  65                                 return;
  66                         if (is_bool_from_context(expr->left->unop))
  67                                 return;
  68                         print = 1;
  69                 }
  70         }
  71
  72         if (expr->type == EXPR_BINOP) {
  73                 if (expr->left->type == EXPR_COMPARE || expr->right->type == EXPR_COMPARE)
  74                         print = 1;
  75         }
  76
  77         if (print) {
  78                 sm_msg("warn: add some parenthesis here?");
  79                 return;
  80         }
  81
  82         if (expr->type == EXPR_BINOP && expr->op == '&') {
  83                 int i = 0;
  84
  85                 if (is_bool_op(expr->left))
  86                         i++;
  87                 if (is_bool_op(expr->right))
  88                         i++;
  89                 if (i == 1)
  90                         sm_msg("warn: maybe use && instead of &");
  91         }
  92 }
  93
  94 static void match_binop(struct expression *expr)
  95 {
  96         if (expr->op != '&')
  97                 return;
  98         if (expr->left->op == '!')
  99                 sm_msg("warn: add some parenthesis here?");
 100 }
 101
 102 void check_precedence(int id)
 103 {
 104         my_id = id;
 105
 106         add_hook(&match_condition, CONDITION_HOOK);
 107         add_hook(&match_binop, BINOP_HOOK);
 108 }