Print this page
11972 resync smatch
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/tools/smatch/src/smatch_mtag_data.c
+++ new/usr/src/tools/smatch/src/smatch_mtag_data.c
1 1 /*
2 2 * Copyright (C) 2016 Oracle.
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 /*
19 19 * What we're doing here is saving all the possible values for static variables.
20 20 * Later on we might do globals as well.
21 21 *
22 22 */
23 23
24 24 #include "smatch.h"
25 25 #include "smatch_slist.h"
26 26 #include "smatch_extra.h"
27 27
28 28 static int my_id;
29 29 static struct stree *vals;
30 30
31 31 static int save_rl(void *_rl, int argc, char **argv, char **azColName)
32 32 {
33 33 unsigned long *rl = _rl;
34 34
35 35 *rl = strtoul(argv[0], NULL, 10);
36 36 return 0;
37 37 }
38 38
39 39 static struct range_list *select_orig(mtag_t tag, int offset)
40 40 {
41 41 struct range_list *rl = NULL;
42 42
43 43 mem_sql(&save_rl, &rl, "select value from mtag_data where tag = %lld and offset = %d;",
44 44 tag, offset);
45 45 return rl;
46 46 }
47 47
48 48 static int is_kernel_param(const char *name)
49 49 {
50 50 struct sm_state *tmp;
51 51 char buf[256];
52 52
53 53 /*
54 54 * I'm ignoring these because otherwise Smatch thinks that kernel
55 55 * parameters are always set to the default.
56 56 *
57 57 */
58 58
59 59 if (option_project != PROJ_KERNEL)
60 60 return 0;
61 61
|
↓ open down ↓ |
61 lines elided |
↑ open up ↑ |
62 62 snprintf(buf, sizeof(buf), "__param_%s.arg", name);
63 63
64 64 FOR_EACH_SM(vals, tmp) {
65 65 if (strcmp(tmp->name, buf) == 0)
66 66 return 1;
67 67 } END_FOR_EACH_SM(tmp);
68 68
69 69 return 0;
70 70 }
71 71
72 +static bool is_ignored_macro(struct expression *expr)
73 +{
74 + char *macro;
75 +
76 + macro = get_macro_name(expr->pos);
77 + if (!macro)
78 + return false;
79 + if (strcmp(macro, "EXPORT_SYMBOL") == 0)
80 + return true;
81 + return false;
82 +}
83 +
72 84 static void insert_mtag_data(mtag_t tag, int offset, struct range_list *rl)
73 85 {
74 86 rl = clone_rl_permanent(rl);
75 87
76 88 mem_sql(NULL, NULL, "delete from mtag_data where tag = %lld and offset = %d and type = %d",
77 89 tag, offset, DATA_VALUE);
78 90 mem_sql(NULL, NULL, "insert into mtag_data values (%lld, %d, %d, '%lu');",
79 91 tag, offset, DATA_VALUE, (unsigned long)rl);
80 92 }
81 93
82 -void update_mtag_data(struct expression *expr)
94 +static bool invalid_type(struct symbol *type)
83 95 {
84 - struct range_list *orig, *new, *rl;
96 + if (!type)
97 + return true;
98 + if (type == &void_ctype)
99 + return true;
100 + if (type->type == SYM_STRUCT ||
101 + type->type == SYM_ARRAY ||
102 + type->type == SYM_UNION)
103 + return true;
104 + return false;
105 +}
106 +
107 +void update_mtag_data(struct expression *expr, struct smatch_state *state)
108 +{
109 + struct range_list *orig, *new;
85 110 struct symbol *type;
86 111 char *name;
87 112 mtag_t tag;
88 113 int offset;
89 114
115 + if (!expr)
116 + return;
117 + if (is_local_variable(expr))
118 + return;
119 + if (is_ignored_macro(expr))
120 + return;
90 121 name = expr_to_var(expr);
91 122 if (is_kernel_param(name)) {
92 123 free_string(name);
93 124 return;
94 125 }
95 126 free_string(name);
96 127
97 128 if (!expr_to_mtag_offset(expr, &tag, &offset))
98 129 return;
99 130
100 131 type = get_type(expr);
101 - if ((offset == 0) &&
102 - (!type || type == &void_ctype ||
103 - type->type == SYM_STRUCT || type->type == SYM_UNION || type->type == SYM_ARRAY))
132 + if (offset == 0 && invalid_type(type))
104 133 return;
105 134
106 - get_absolute_rl(expr, &rl);
107 -
108 135 orig = select_orig(tag, offset);
109 - new = rl_union(orig, rl);
136 + new = rl_union(orig, estate_rl(state));
110 137 insert_mtag_data(tag, offset, new);
111 138 }
112 139
113 140 static void match_global_assign(struct expression *expr)
114 141 {
115 142 struct range_list *rl;
116 143 mtag_t tag;
117 144 int offset;
118 145 char *name;
119 146
147 + if (is_ignored_macro(expr))
148 + return;
120 149 name = expr_to_var(expr->left);
121 150 if (is_kernel_param(name)) {
122 151 free_string(name);
123 152 return;
124 153 }
125 154 free_string(name);
126 155
127 156 if (!expr_to_mtag_offset(expr->left, &tag, &offset))
128 157 return;
129 158
130 159 get_absolute_rl(expr->right, &rl);
131 160 insert_mtag_data(tag, offset, rl);
132 161 }
133 162
134 163 static int save_mtag_data(void *_unused, int argc, char **argv, char **azColName)
135 164 {
136 165 struct range_list *rl;
137 166
138 167 if (argc != 4) {
139 168 sm_msg("Error saving mtag data");
140 169 return 0;
141 170 }
142 171 if (!option_info)
143 172 return 0;
144 173
145 174 rl = (struct range_list *)strtoul(argv[3], NULL, 10);
146 175 sm_msg("SQL: insert into mtag_data values ('%s', '%s', '%s', '%s');",
147 176 argv[0], argv[1], argv[2], show_rl(rl));
148 177
149 178 return 0;
150 179 }
151 180
152 181 static void match_end_file(struct symbol_list *sym_list)
153 182 {
154 183 mem_sql(&save_mtag_data, NULL, "select * from mtag_data where type = %d;",
155 184 DATA_VALUE);
156 185 }
157 186
158 187 struct db_info {
159 188 struct symbol *type;
160 189 struct range_list *rl;
161 190 };
162 191
163 192 static int get_vals(void *_db_info, int argc, char **argv, char **azColName)
164 193 {
165 194 struct db_info *db_info = _db_info;
166 195 struct range_list *tmp;
167 196
168 197 str_to_rl(db_info->type, argv[0], &tmp);
169 198 if (db_info->rl)
170 199 db_info->rl = rl_union(db_info->rl, tmp);
171 200 else
172 201 db_info->rl = tmp;
173 202
174 203 return 0;
175 204 }
176 205
177 206 struct db_cache_results {
178 207 mtag_t tag;
179 208 struct range_list *rl;
180 209 };
|
↓ open down ↓ |
51 lines elided |
↑ open up ↑ |
181 210 static struct db_cache_results cached_results[8];
182 211
183 212 static int get_rl_from_mtag_offset(mtag_t tag, int offset, struct symbol *type, struct range_list **rl)
184 213 {
185 214 struct db_info db_info = {};
186 215 mtag_t merged = tag | offset;
187 216 static int idx;
188 217 int ret;
189 218 int i;
190 219
191 - if (!type || type == &void_ctype ||
192 - (type->type == SYM_STRUCT || type->type == SYM_ARRAY || type->type == SYM_UNION))
193 - return 0;
194 -
195 220 for (i = 0; i < ARRAY_SIZE(cached_results); i++) {
196 221 if (merged == cached_results[i].tag) {
197 222 if (cached_results[i].rl) {
198 223 *rl = cached_results[i].rl;
199 224 return 1;
200 225 }
201 226 return 0;
202 227 }
203 228 }
204 229
205 230 db_info.type = type;
206 231
207 232 run_sql(get_vals, &db_info,
208 233 "select value from mtag_data where tag = %lld and offset = %d and type = %d;",
209 234 tag, offset, DATA_VALUE);
210 235 if (!db_info.rl || is_whole_rl(db_info.rl)) {
211 236 db_info.rl = NULL;
212 237 ret = 0;
213 238 goto update_cache;
214 239 }
215 240
216 241 *rl = db_info.rl;
217 242 ret = 1;
218 243
219 244 update_cache:
220 245 cached_results[idx].tag = merged;
221 246 cached_results[idx].rl = db_info.rl;
222 247 idx = (idx + 1) % ARRAY_SIZE(cached_results);
223 248
224 249 return ret;
225 250 }
226 251
227 252 static void clear_cache(struct symbol *sym)
|
↓ open down ↓ |
23 lines elided |
↑ open up ↑ |
228 253 {
229 254 memset(cached_results, 0, sizeof(cached_results));
230 255 }
231 256
232 257 int get_mtag_rl(struct expression *expr, struct range_list **rl)
233 258 {
234 259 struct symbol *type;
235 260 mtag_t tag;
236 261 int offset;
237 262
263 + if (is_local_variable(expr))
264 + return 0;
238 265 if (!expr_to_mtag_offset(expr, &tag, &offset))
239 266 return 0;
240 267 if (offset >= MTAG_OFFSET_MASK)
241 268 return 0;
242 269
243 270 type = get_type(expr);
244 - if (!type)
271 + if (invalid_type(type))
245 272 return 0;
246 273
247 274 return get_rl_from_mtag_offset(tag, offset, type, rl);
248 275 }
249 276
250 277 void register_mtag_data(int id)
251 278 {
252 279 my_id = id;
253 280
254 281 add_hook(&clear_cache, FUNC_DEF_HOOK);
255 282
256 283 // if (!option_info)
257 284 // return;
258 285 add_hook(&match_global_assign, GLOBAL_ASSIGNMENT_HOOK);
259 286 add_hook(&match_end_file, END_FILE_HOOK);
260 287 }
261 288
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX