11506 smatch resync
1 /*
2 * Copyright (C) 2012 Oracle.
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 #include "scope.h"
19 #include "smatch.h"
20 #include "smatch_slist.h"
21 #include "smatch_expression_stacks.h"
22
23 static int my_id;
24
25 static struct string_list *ignored_macros;
26 static struct position old_pos;
27
28 static struct smatch_state *alloc_my_state(struct expression *expr)
29 {
30 struct smatch_state *state;
31 char *name;
32
33 state = __alloc_smatch_state(0);
34 expr = strip_expr(expr);
35 name = expr_to_str(expr);
36 state->name = alloc_sname(name);
37 free_string(name);
38 state->data = expr;
39 return state;
40 }
41
42 static int defined_inside_macro(struct position macro_pos, struct expression *expr)
43 {
44 char *name;
45 struct symbol *sym;
46 int ret = 0;
47
48 name = expr_to_var_sym(expr, &sym);
49 if (!name || !sym)
50 goto free;
51 if (!sym->scope || !sym->scope->token)
52 goto free;
53 if (positions_eq(macro_pos, sym->scope->token->pos))
54 ret = 1;
55 free:
56 free_string(name);
57 return ret;
58 }
59
60 static int affected_inside_macro_before(struct expression *expr)
61 {
62 struct sm_state *sm;
63 struct sm_state *tmp;
64 struct expression *old_mod;
65
66 sm = get_sm_state_expr(my_id, expr);
67 if (!sm)
68 return 0;
69
70 FOR_EACH_PTR(sm->possible, tmp) {
71 old_mod = tmp->state->data;
72 if (!old_mod)
73 continue;
74 if (positions_eq(old_mod->pos, expr->pos))
75 return 1;
76 } END_FOR_EACH_PTR(tmp);
77 return 0;
78 }
79
80 static int is_ignored_macro(const char *macro)
81 {
82 char *tmp;
83
84 FOR_EACH_PTR(ignored_macros, tmp) {
85 if (!strcmp(tmp, macro))
86 return 1;
87 } END_FOR_EACH_PTR(tmp);
88 return 0;
89 }
90
91 static void match_unop(struct expression *raw_expr)
92 {
93 struct expression *expr;
94 char *macro, *name;
95
96 if (raw_expr->op != SPECIAL_INCREMENT && raw_expr->op != SPECIAL_DECREMENT)
97 return;
98
99 macro = get_macro_name(raw_expr->pos);
100 if (!macro)
101 return;
102
103 expr = strip_expr(raw_expr->unop);
104
105 if (defined_inside_macro(expr->pos, expr))
106 return;
107
108 if (is_ignored_macro(macro))
109 return;
110
111 if (!affected_inside_macro_before(expr)) {
112 set_state_expr(my_id, expr, alloc_my_state(expr));
113 old_pos = expr->pos;
114 return;
115 }
116
117 if (!positions_eq(old_pos, expr->pos))
118 return;
119
120 name = expr_to_str(raw_expr);
121 sm_warning("side effect in macro '%s' doing '%s'",
122 macro, name);
123 free_string(name);
124 }
125
126 static void match_stmt(struct statement *stmt)
127 {
128 if (!positions_eq(old_pos, stmt->pos))
129 old_pos.line = 0;
130 }
131
132 static void register_ignored_macros(void)
133 {
134 struct token *token;
135 char *macro;
136 char name[256];
137
138 snprintf(name, 256, "%s.ignore_side_effects", option_project_str);
139
140 token = get_tokens_file(name);
141 if (!token)
142 return;
143 if (token_type(token) != TOKEN_STREAMBEGIN)
144 return;
145 token = token->next;
146 while (token_type(token) != TOKEN_STREAMEND) {
147 if (token_type(token) != TOKEN_IDENT)
148 return;
149 macro = alloc_string(show_ident(token->ident));
150 add_ptr_list(&ignored_macros, macro);
151 token = token->next;
152 }
153 clear_token_alloc();
154 }
155
156 void check_macro_side_effects(int id)
157 {
158 my_id = id;
159
160 if (!option_spammy)
161 return;
162
163 add_hook(&match_unop, OP_HOOK);
164 add_hook(&match_stmt, STMT_HOOK);
165 register_ignored_macros();
166 }
--- EOF ---