check_or_vs_and.c

   1 /*
   2  * sparse/check_or_vs_and.c
   3  *
   4  * Copyright (C) 2012 Oracle.
   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 expr_equiv(struct expression *one, struct expression *two)
  15 {
  16         struct symbol *one_sym, *two_sym;
  17         char *one_name = NULL;
  18         char *two_name = NULL;
  19         int ret = 0;
  20
  21         one_name = get_variable_from_expr_complex(one, &one_sym);
  22         if (!one_name || !one_sym)
  23                 goto free;
  24         two_name = get_variable_from_expr_complex(two, &two_sym);
  25         if (!two_name || !two_sym)
  26                 goto free;
  27         if (one_sym != two_sym)
  28                 goto free;
  29         if (strcmp(one_name, two_name) == 0)
  30                 ret = 1;
  31 free:
  32         free_string(one_name);
  33         free_string(two_name);
  34         return ret;
  35 }
  36
  37 static int inconsistent_check(struct expression *left, struct expression *right)
  38 {
  39         long long val;
  40
  41         if (get_value(left->left, &val)) {
  42                 if (get_value(right->left, &val))
  43                         return expr_equiv(left->right, right->right);
  44                 if (get_value(right->right, &val))
  45                         return expr_equiv(left->right, right->left);
  46                 return 0;
  47         }
  48         if (get_value(left->right, &val)) {
  49                 if (get_value(right->left, &val))
  50                         return expr_equiv(left->left, right->right);
  51                 if (get_value(right->right, &val))
  52                         return expr_equiv(left->left, right->left);
  53                 return 0;
  54         }
  55
  56         return 0;
  57 }
  58
  59 static void check_or(struct expression *expr)
  60 {
  61         if (expr->left->type != EXPR_COMPARE ||
  62                         expr->left->op != SPECIAL_NOTEQUAL)
  63                 return;
  64         if (expr->right->type != EXPR_COMPARE ||
  65                         expr->right->op != SPECIAL_NOTEQUAL)
  66                 return;
  67         if (!inconsistent_check(expr->left, expr->right))
  68                 return;
  69
  70         sm_msg("warn: was && intended here instead of ||?");
  71 }
  72
  73 static void check_and(struct expression *expr)
  74 {
  75         if (expr->left->type != EXPR_COMPARE ||
  76                         expr->left->op != SPECIAL_EQUAL)
  77                 return;
  78         if (expr->right->type != EXPR_COMPARE ||
  79                         expr->right->op != SPECIAL_EQUAL)
  80                 return;
  81         if (!inconsistent_check(expr->left, expr->right))
  82                 return;
  83
  84         sm_msg("warn: was || intended here instead of &&?");
  85 }
  86
  87 static void match_logic(struct expression *expr)
  88 {
  89         if (expr->type != EXPR_LOGICAL)
  90                 return;
  91
  92         if (expr->op == SPECIAL_LOGICAL_OR)
  93                 check_or(expr);
  94         if (expr->op == SPECIAL_LOGICAL_AND)
  95                 check_and(expr);
  96 }
  97
  98 void check_or_vs_and(int id)
  99 {
 100         my_id = id;
 101
 102         add_hook(&match_logic, LOGIC_HOOK);
 103 }