Print this page
11506 smatch resync
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/tools/smatch/src/check_precedence.c
+++ new/usr/src/tools/smatch/src/check_precedence.c
1 1 /*
2 2 * Copyright (C) 2010 Dan Carpenter.
3 3 *
4 4 * This program is free software; you can redistribute it and/or
5 5 * modify it under the terms of the GNU General Public License
6 6 * as published by the Free Software Foundation; either version 2
7 7 * of the License, or (at your option) any later version.
8 8 *
9 9 * This program is distributed in the hope that it will be useful,
10 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 12 * GNU General Public License for more details.
13 13 *
14 14 * You should have received a copy of the GNU General Public License
15 15 * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
16 16 */
17 17
18 18 #include "smatch.h"
19 19 #include "smatch_extra.h"
20 20
21 21 static int my_id;
22 22
23 23 static int is_bool(struct expression *expr)
24 24 {
25 25 struct symbol *type;
26 26
27 27 type = get_type(expr);
28 28 if (!type)
29 29 return 0;
30 30 if (type_bits(type) == 1 && type->ctype.modifiers & MOD_UNSIGNED)
31 31 return 1;
32 32 return 0;
33 33 }
34 34
35 35 static int is_bool_from_context(struct expression *expr)
36 36 {
37 37 sval_t sval;
38 38
39 39 if (!get_implied_max(expr, &sval) || sval.uvalue > 1)
40 40 return 0;
41 41 if (!get_implied_min(expr, &sval) || sval.value < 0)
42 42 return 0;
43 43 return 1;
44 44 }
45 45
46 46 static int is_bool_op(struct expression *expr)
47 47 {
48 48 expr = strip_expr(expr);
49 49
50 50 if (expr->type == EXPR_PREOP && expr->op == '!')
51 51 return 1;
52 52 if (expr->type == EXPR_COMPARE)
53 53 return 1;
54 54 if (expr->type == EXPR_LOGICAL)
55 55 return 1;
56 56 return is_bool(expr);
57 57 }
58 58
59 59 static void match_condition(struct expression *expr)
60 60 {
61 61 int print = 0;
62 62
63 63 if (expr->type == EXPR_COMPARE) {
64 64 if (expr->left->type == EXPR_COMPARE || expr->right->type == EXPR_COMPARE)
65 65 print = 1;
66 66 if (expr->left->type == EXPR_PREOP && expr->left->op == '!') {
67 67 if (expr->left->unop->type == EXPR_PREOP && expr->left->unop->op == '!')
68 68 return;
69 69 if (expr->right->op == '!')
70 70 return;
71 71 if (is_bool(expr->right))
72 72 return;
73 73 if (is_bool(expr->left->unop))
74 74 return;
75 75 if (is_bool_from_context(expr->left->unop))
76 76 return;
77 77 print = 1;
78 78 }
79 79 }
80 80
81 81 if (expr->type == EXPR_BINOP) {
82 82 if (expr->left->type == EXPR_COMPARE || expr->right->type == EXPR_COMPARE)
83 83 print = 1;
84 84 }
85 85
86 86 if (print) {
87 87 sm_warning("add some parenthesis here?");
88 88 return;
89 89 }
90 90
91 91 if (expr->type == EXPR_BINOP && expr->op == '&') {
92 92 int i = 0;
93 93
94 94 if (is_bool_op(expr->left))
95 95 i++;
96 96 if (is_bool_op(expr->right))
97 97 i++;
98 98 if (i == 1)
99 99 sm_warning("maybe use && instead of &");
100 100 }
101 101 }
102 102
103 103 static void match_binop(struct expression *expr)
104 104 {
105 105 if (expr->op != '&')
106 106 return;
107 107 if (expr->left->op == '!')
108 108 sm_warning("add some parenthesis here?");
109 109 }
110 110
111 111 static void match_mask(struct expression *expr)
112 112 {
|
↓ open down ↓ |
112 lines elided |
↑ open up ↑ |
113 113 if (expr->op != '&')
114 114 return;
115 115 if (expr->right->type != EXPR_BINOP)
116 116 return;
117 117 if (expr->right->op != SPECIAL_RIGHTSHIFT)
118 118 return;
119 119
120 120 sm_warning("shift has higher precedence than mask");
121 121 }
122 122
123 +static void match_mask_compare(struct expression *expr)
124 +{
125 + if (expr->op != '&')
126 + return;
127 + if (expr->right->type != EXPR_COMPARE)
128 + return;
129 +
130 + sm_warning("compare has higher precedence than mask");
131 +}
132 +
123 133 static void match_subtract_shift(struct expression *expr)
124 134 {
125 135 if (expr->op != SPECIAL_LEFTSHIFT)
126 136 return;
127 137 if (expr->right->type != EXPR_BINOP)
128 138 return;
129 139 if (expr->right->op != '-')
130 140 return;
131 141 sm_warning("subtract is higher precedence than shift");
132 142 }
133 143
134 144 void check_precedence(int id)
135 145 {
136 146 my_id = id;
137 147
138 148 add_hook(&match_condition, CONDITION_HOOK);
139 149 add_hook(&match_binop, BINOP_HOOK);
140 150 add_hook(&match_mask, BINOP_HOOK);
151 + add_hook(&match_mask_compare, BINOP_HOOK);
141 152 add_hook(&match_subtract_shift, BINOP_HOOK);
142 153 }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX