1 /*
2 * Copyright (C) 2009 Dan Carpenter.
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 <string.h>
19
20 #include "smatch.h"
21 #include "smatch_slist.h"
22 #include "smatch_extra.h"
23
24 void show_sname_alloc(void);
25 void show_data_range_alloc(void);
26 void show_ptrlist_alloc(void);
27 void show_rl_ptrlist_alloc(void);
28 void show_sm_state_alloc(void);
29
30 int local_debug;
31 static int my_id;
32 char *trace_variable;
33
match_all_values(const char * fn,struct expression * expr,void * info)34 static void match_all_values(const char *fn, struct expression *expr, void *info)
35 {
36 struct stree *stree;
37
38 stree = get_all_states_stree(SMATCH_EXTRA);
39 __print_stree(stree);
40 free_stree(&stree);
41 }
42
match_cur_stree(const char * fn,struct expression * expr,void * info)43 static void match_cur_stree(const char *fn, struct expression *expr, void *info)
44 {
45 __print_cur_stree();
46 }
47
match_state(const char * fn,struct expression * expr,void * info)48 static void match_state(const char *fn, struct expression *expr, void *info)
49 {
50 struct expression *check_arg, *state_arg;
51 struct sm_state *sm;
52 int found = 0;
53
54 check_arg = get_argument_from_call_expr(expr->args, 0);
55 if (check_arg->type != EXPR_STRING) {
56 sm_error("the check_name argument to %s is supposed to be a string literal", fn);
57 return;
58 }
59 state_arg = get_argument_from_call_expr(expr->args, 1);
60 if (!state_arg || state_arg->type != EXPR_STRING) {
61 sm_error("the state_name argument to %s is supposed to be a string literal", fn);
62 return;
63 }
64
65 FOR_EACH_SM(__get_cur_stree(), sm) {
66 if (strcmp(check_name(sm->owner), check_arg->string->data) != 0)
67 continue;
68 if (strcmp(sm->name, state_arg->string->data) != 0)
69 continue;
70 sm_msg("'%s' = '%s'", sm->name, sm->state->name);
71 found = 1;
72 } END_FOR_EACH_SM(sm);
73
74 if (!found)
75 sm_msg("%s '%s' not found", check_arg->string->data, state_arg->string->data);
76 }
77
match_states(const char * fn,struct expression * expr,void * info)78 static void match_states(const char *fn, struct expression *expr, void *info)
79 {
80 struct expression *check_arg;
81
82 check_arg = get_argument_from_call_expr(expr->args, 0);
83 if (check_arg->type != EXPR_STRING) {
84 sm_error("the check_name argument to %s is supposed to be a string literal", fn);
85 return;
86 }
87
88 if (__print_states(check_arg->string->data))
89 return;
90
91 if (!id_from_name(check_arg->string->data))
92 sm_msg("invalid check name '%s'", check_arg->string->data);
93 else
94 sm_msg("%s: no states", check_arg->string->data);
95 }
96
match_print_value(const char * fn,struct expression * expr,void * info)97 static void match_print_value(const char *fn, struct expression *expr, void *info)
98 {
99 struct stree *stree;
100 struct sm_state *tmp;
101 struct expression *arg_expr;
102
103 arg_expr = get_argument_from_call_expr(expr->args, 0);
104 if (arg_expr->type != EXPR_STRING) {
105 sm_error("the argument to %s is supposed to be a string literal", fn);
106 return;
107 }
108
109 stree = __get_cur_stree();
110 FOR_EACH_MY_SM(SMATCH_EXTRA, stree, tmp) {
111 if (!strcmp(tmp->name, arg_expr->string->data))
112 sm_msg("%s = %s", tmp->name, tmp->state->name);
113 } END_FOR_EACH_SM(tmp);
114 }
115
match_print_known(const char * fn,struct expression * expr,void * info)116 static void match_print_known(const char *fn, struct expression *expr, void *info)
117 {
118 struct expression *arg;
119 struct range_list *rl = NULL;
120 char *name;
121 int known = 0;
122 sval_t sval;
123
124 arg = get_argument_from_call_expr(expr->args, 0);
125 if (get_value(arg, &sval))
126 known = 1;
127
128 get_implied_rl(arg, &rl);
129
130 name = expr_to_str(arg);
131 sm_msg("known: '%s' = '%s'. implied = '%s'", name, known ? sval_to_str(sval) : "<unknown>", show_rl(rl));
132 free_string(name);
133 }
134
match_print_implied(const char * fn,struct expression * expr,void * info)135 static void match_print_implied(const char *fn, struct expression *expr, void *info)
136 {
137 struct expression *arg;
138 struct range_list *rl = NULL;
139 char *name;
140
141 arg = get_argument_from_call_expr(expr->args, 0);
142 get_implied_rl(arg, &rl);
143
144 name = expr_to_str(arg);
145 sm_msg("implied: %s = '%s'", name, show_rl(rl));
146 free_string(name);
147 }
148
match_real_absolute(const char * fn,struct expression * expr,void * info)149 static void match_real_absolute(const char *fn, struct expression *expr, void *info)
150 {
151 struct expression *arg;
152 struct range_list *rl = NULL;
153 char *name;
154
155 arg = get_argument_from_call_expr(expr->args, 0);
156 get_real_absolute_rl(arg, &rl);
157
158 name = expr_to_str(arg);
159 sm_msg("real absolute: %s = '%s'", name, show_rl(rl));
160 free_string(name);
161 }
162
match_print_implied_min(const char * fn,struct expression * expr,void * info)163 static void match_print_implied_min(const char *fn, struct expression *expr, void *info)
164 {
165 struct expression *arg;
166 sval_t sval;
167 char *name;
168
169 arg = get_argument_from_call_expr(expr->args, 0);
170 name = expr_to_str(arg);
171
172 if (get_implied_min(arg, &sval))
173 sm_msg("implied min: %s = %s", name, sval_to_str(sval));
174 else
175 sm_msg("implied min: %s = <unknown>", name);
176
177 free_string(name);
178 }
179
match_print_implied_max(const char * fn,struct expression * expr,void * info)180 static void match_print_implied_max(const char *fn, struct expression *expr, void *info)
181 {
182 struct expression *arg;
183 sval_t sval;
184 char *name;
185
186 arg = get_argument_from_call_expr(expr->args, 0);
187 name = expr_to_str(arg);
188
189 if (get_implied_max(arg, &sval))
190 sm_msg("implied max: %s = %s", name, sval_to_str(sval));
191 else
192 sm_msg("implied max: %s = <unknown>", name);
193
194 free_string(name);
195 }
196
match_user_rl(const char * fn,struct expression * expr,void * info)197 static void match_user_rl(const char *fn, struct expression *expr, void *info)
198 {
199 struct expression *arg;
200 struct range_list *rl = NULL;
201 bool capped = false;
202 char *name;
203
204 if (option_project != PROJ_KERNEL)
205 sm_msg("no user data for project = '%s'", option_project_str);
206
207 arg = get_argument_from_call_expr(expr->args, 0);
208 name = expr_to_str(arg);
209
210 get_user_rl(arg, &rl);
211 if (rl)
212 capped = user_rl_capped(arg);
213 sm_msg("user rl: '%s' = '%s'%s", name, show_rl(rl), capped ? " (capped)" : "");
214
215 free_string(name);
216 }
217
match_capped(const char * fn,struct expression * expr,void * info)218 static void match_capped(const char *fn, struct expression *expr, void *info)
219 {
220 struct expression *arg;
221 char *name;
222
223 arg = get_argument_from_call_expr(expr->args, 0);
224 name = expr_to_str(arg);
225 sm_msg("'%s' = '%s'", name, is_capped(arg) ? "capped" : "not capped");
226 free_string(name);
227 }
228
match_print_hard_max(const char * fn,struct expression * expr,void * info)229 static void match_print_hard_max(const char *fn, struct expression *expr, void *info)
230 {
231 struct expression *arg;
232 sval_t sval;
233 char *name;
234
235 arg = get_argument_from_call_expr(expr->args, 0);
236 name = expr_to_str(arg);
237
238 if (get_hard_max(arg, &sval))
239 sm_msg("hard max: %s = %s", name, sval_to_str(sval));
240 else
241 sm_msg("hard max: %s = <unknown>", name);
242
243 free_string(name);
244 }
245
match_print_fuzzy_max(const char * fn,struct expression * expr,void * info)246 static void match_print_fuzzy_max(const char *fn, struct expression *expr, void *info)
247 {
248 struct expression *arg;
249 sval_t sval;
250 char *name;
251
252 arg = get_argument_from_call_expr(expr->args, 0);
253 name = expr_to_str(arg);
254
255 if (get_fuzzy_max(arg, &sval))
256 sm_msg("fuzzy max: %s = %s", name, sval_to_str(sval));
257 else
258 sm_msg("fuzzy max: %s = <unknown>", name);
259
260 free_string(name);
261 }
262
match_print_absolute(const char * fn,struct expression * expr,void * info)263 static void match_print_absolute(const char *fn, struct expression *expr, void *info)
264 {
265 struct expression *arg;
266 struct range_list *rl;
267 char *name;
268
269 arg = get_argument_from_call_expr(expr->args, 0);
270 name = expr_to_str(arg);
271
272 get_absolute_rl(arg, &rl);
273 sm_msg("absolute: %s = %s", name, show_rl(rl));
274
275 free_string(name);
276 }
277
match_print_absolute_min(const char * fn,struct expression * expr,void * info)278 static void match_print_absolute_min(const char *fn, struct expression *expr, void *info)
279 {
280 struct expression *arg;
281 sval_t sval;
282 char *name;
283
284 arg = get_argument_from_call_expr(expr->args, 0);
285 name = expr_to_str(arg);
286
287 if (get_absolute_min(arg, &sval))
288 sm_msg("absolute min: %s = %s", name, sval_to_str(sval));
289 else
290 sm_msg("absolute min: %s = <unknown>", name);
291
292 free_string(name);
293 }
294
match_print_absolute_max(const char * fn,struct expression * expr,void * info)295 static void match_print_absolute_max(const char *fn, struct expression *expr, void *info)
296 {
297 struct expression *arg;
298 sval_t sval;
299 char *name;
300
301 arg = get_argument_from_call_expr(expr->args, 0);
302 get_absolute_max(arg, &sval);
303
304 name = expr_to_str(arg);
305 sm_msg("absolute max: %s = %s", name, sval_to_str(sval));
306 free_string(name);
307 }
308
match_sval_info(const char * fn,struct expression * expr,void * info)309 static void match_sval_info(const char *fn, struct expression *expr, void *info)
310 {
311 struct expression *arg;
312 sval_t sval;
313 char *name;
314
315 arg = get_argument_from_call_expr(expr->args, 0);
316 name = expr_to_str(arg);
317
318 if (!get_implied_value(arg, &sval)) {
319 sm_msg("no sval for '%s'", name);
320 goto free;
321 }
322
323 sm_msg("implied: %s %c%d ->value = %llx", name, sval_unsigned(sval) ? 'u' : 's', sval_bits(sval), sval.value);
324 free:
325 free_string(name);
326 }
327
match_member_name(const char * fn,struct expression * expr,void * info)328 static void match_member_name(const char *fn, struct expression *expr, void *info)
329 {
330 struct expression *arg;
331 char *name, *member_name;
332
333 arg = get_argument_from_call_expr(expr->args, 0);
334 name = expr_to_str(arg);
335 member_name = get_member_name(arg);
336 sm_msg("member name: '%s => %s'", name, member_name);
337 free_string(member_name);
338 free_string(name);
339 }
340
print_possible(struct sm_state * sm)341 static void print_possible(struct sm_state *sm)
342 {
343 struct sm_state *tmp;
344
345 sm_msg("Possible values for %s", sm->name);
346 FOR_EACH_PTR(sm->possible, tmp) {
347 printf("%s\n", tmp->state->name);
348 } END_FOR_EACH_PTR(tmp);
349 sm_msg("===");
350 }
351
match_possible(const char * fn,struct expression * expr,void * info)352 static void match_possible(const char *fn, struct expression *expr, void *info)
353 {
354 struct stree *stree;
355 struct sm_state *tmp;
356 struct expression *arg_expr;
357
358 arg_expr = get_argument_from_call_expr(expr->args, 0);
359 if (arg_expr->type != EXPR_STRING) {
360 sm_error("the argument to %s is supposed to be a string literal", fn);
361 return;
362 }
363
364 stree = __get_cur_stree();
365 FOR_EACH_MY_SM(SMATCH_EXTRA, stree, tmp) {
366 if (!strcmp(tmp->name, arg_expr->string->data))
367 print_possible(tmp);
368 } END_FOR_EACH_SM(tmp);
369 }
370
match_strlen(const char * fn,struct expression * expr,void * info)371 static void match_strlen(const char *fn, struct expression *expr, void *info)
372 {
373 struct expression *arg;
374 struct range_list *rl;
375 char *name;
376
377 arg = get_argument_from_call_expr(expr->args, 0);
378 get_implied_strlen(arg, &rl);
379
380 name = expr_to_str(arg);
381 sm_msg("strlen: '%s' %s characters", name, show_rl(rl));
382 free_string(name);
383 }
384
match_buf_size(const char * fn,struct expression * expr,void * info)385 static void match_buf_size(const char *fn, struct expression *expr, void *info)
386 {
387 struct expression *arg, *comp;
388 struct range_list *rl;
389 int elements, bytes;
390 char *name;
391 char buf[256] = "";
392 int limit_type;
393 int n;
394 sval_t sval;
395
396 arg = get_argument_from_call_expr(expr->args, 0);
397
398 elements = get_array_size(arg);
399 bytes = get_array_size_bytes_max(arg);
400 rl = get_array_size_bytes_rl(arg);
401 comp = get_size_variable(arg, &limit_type);
402
403 name = expr_to_str(arg);
404 n = snprintf(buf, sizeof(buf), "buf size: '%s' %d elements, %d bytes", name, elements, bytes);
405 free_string(name);
406
407 if (!rl_to_sval(rl, &sval))
408 n += snprintf(buf + n, sizeof(buf) - n, " (rl = %s)", show_rl(rl));
409
410 if (comp) {
411 name = expr_to_str(comp);
412 snprintf(buf + n, sizeof(buf) - n, "[size_var=%s %s]", limit_type_str(limit_type), name);
413 free_string(name);
414 }
415 sm_msg("%s", buf);
416 }
417
match_note(const char * fn,struct expression * expr,void * info)418 static void match_note(const char *fn, struct expression *expr, void *info)
419 {
420 struct expression *arg_expr;
421
422 arg_expr = get_argument_from_call_expr(expr->args, 0);
423 if (arg_expr->type != EXPR_STRING) {
424 sm_error("the argument to %s is supposed to be a string literal", fn);
425 return;
426 }
427 sm_msg("%s", arg_expr->string->data);
428 }
429
print_related(struct sm_state * sm)430 static void print_related(struct sm_state *sm)
431 {
432 struct relation *rel;
433
434 if (!estate_related(sm->state))
435 return;
436
437 sm_prefix();
438 sm_printf("%s: ", sm->name);
439 FOR_EACH_PTR(estate_related(sm->state), rel) {
440 sm_printf("%s ", rel->name);
441 } END_FOR_EACH_PTR(rel);
442 sm_printf("\n");
443 }
444
match_dump_related(const char * fn,struct expression * expr,void * info)445 static void match_dump_related(const char *fn, struct expression *expr, void *info)
446 {
447 struct stree *stree;
448 struct sm_state *tmp;
449
450 stree = __get_cur_stree();
451 FOR_EACH_MY_SM(SMATCH_EXTRA, stree, tmp) {
452 print_related(tmp);
453 } END_FOR_EACH_SM(tmp);
454 }
455
match_compare(const char * fn,struct expression * expr,void * info)456 static void match_compare(const char *fn, struct expression *expr, void *info)
457 {
458 struct expression *one, *two;
459 char *one_name, *two_name;
460 int comparison;
461 char buf[16];
462
463 one = get_argument_from_call_expr(expr->args, 0);
464 two = get_argument_from_call_expr(expr->args, 1);
465
466 comparison = get_comparison(one, two);
467 if (!comparison)
468 snprintf(buf, sizeof(buf), "<none>");
469 else
470 snprintf(buf, sizeof(buf), "%s", show_special(comparison));
471
472 one_name = expr_to_str(one);
473 two_name = expr_to_str(two);
474
475 sm_msg("%s %s %s", one_name, buf, two_name);
476
477 free_string(one_name);
478 free_string(two_name);
479 }
480
match_debug_on(const char * fn,struct expression * expr,void * info)481 static void match_debug_on(const char *fn, struct expression *expr, void *info)
482 {
483 option_debug = 1;
484 }
485
match_debug_check(const char * fn,struct expression * expr,void * info)486 static void match_debug_check(const char *fn, struct expression *expr, void *info)
487 {
488 struct expression *arg;
489
490 arg = get_argument_from_call_expr(expr->args, 0);
491 if (!arg || arg->type != EXPR_STRING)
492 return;
493 option_debug_check = arg->string->data;
494 sm_msg("arg = '%s'", option_debug_check);
495 }
496
match_debug_off(const char * fn,struct expression * expr,void * info)497 static void match_debug_off(const char *fn, struct expression *expr, void *info)
498 {
499 option_debug_check = (char *)"";
500 option_debug = 0;
501 }
502
match_local_debug_on(const char * fn,struct expression * expr,void * info)503 static void match_local_debug_on(const char *fn, struct expression *expr, void *info)
504 {
505 local_debug = 1;
506 }
507
match_local_debug_off(const char * fn,struct expression * expr,void * info)508 static void match_local_debug_off(const char *fn, struct expression *expr, void *info)
509 {
510 local_debug = 0;
511 }
512
match_debug_db_on(const char * fn,struct expression * expr,void * info)513 static void match_debug_db_on(const char *fn, struct expression *expr, void *info)
514 {
515 debug_db = 1;
516 }
517
match_debug_db_off(const char * fn,struct expression * expr,void * info)518 static void match_debug_db_off(const char *fn, struct expression *expr, void *info)
519 {
520 debug_db = 0;
521 }
522
mtag_info(struct expression * expr)523 static void mtag_info(struct expression *expr)
524 {
525 mtag_t tag = 0;
526 int offset = 0;
527 struct range_list *rl = NULL;
528
529 expr_to_mtag_offset(expr, &tag, &offset);
530 get_mtag_rl(expr, &rl);
531 sm_msg("mtag = %llu offset = %d rl = '%s'", tag, offset, show_rl(rl));
532 }
533
match_about(const char * fn,struct expression * expr,void * info)534 static void match_about(const char *fn, struct expression *expr, void *info)
535 {
536 struct expression *arg;
537 struct sm_state *sm;
538 char *name;
539
540 sm_msg("---- about ----");
541 match_print_implied(fn, expr, NULL);
542 match_buf_size(fn, expr, NULL);
543 match_strlen(fn, expr, NULL);
544 match_real_absolute(fn, expr, NULL);
545 mtag_info(expr);
546
547 arg = get_argument_from_call_expr(expr->args, 0);
548 name = expr_to_str(arg);
549 if (!name) {
550 sm_msg("info: not a straight forward variable.");
551 return;
552 }
553
554 FOR_EACH_SM(__get_cur_stree(), sm) {
555 if (strcmp(sm->name, name) != 0)
556 continue;
557 sm_msg("%s", show_sm(sm));
558 } END_FOR_EACH_SM(sm);
559 }
560
match_intersection(const char * fn,struct expression * expr,void * info)561 static void match_intersection(const char *fn, struct expression *expr, void *info)
562 {
563 struct expression *one, *two;
564 struct range_list *one_rl, *two_rl;
565 struct range_list *res;
566
567 one = get_argument_from_call_expr(expr->args, 0);
568 two = get_argument_from_call_expr(expr->args, 1);
569
570 get_absolute_rl(one, &one_rl);
571 get_absolute_rl(two, &two_rl);
572
573 res = rl_intersection(one_rl, two_rl);
574 sm_msg("'%s' intersect '%s' is '%s'", show_rl(one_rl), show_rl(two_rl), show_rl(res));
575 }
576
match_type(const char * fn,struct expression * expr,void * info)577 static void match_type(const char *fn, struct expression *expr, void *info)
578 {
579 struct expression *one;
580 struct symbol *type;
581 char *name;
582
583 one = get_argument_from_call_expr(expr->args, 0);
584 type = get_type(one);
585 name = expr_to_str(one);
586 sm_msg("type of '%s' is: '%s'", name, type_to_str(type));
587 free_string(name);
588 }
589
match_type_rl_return(struct expression * call,void * unused,struct range_list ** rl)590 static int match_type_rl_return(struct expression *call, void *unused, struct range_list **rl)
591 {
592 struct expression *one, *two;
593 struct symbol *type;
594
595 one = get_argument_from_call_expr(call->args, 0);
596 type = get_type(one);
597
598 two = get_argument_from_call_expr(call->args, 1);
599 if (!two || two->type != EXPR_STRING) {
600 sm_msg("expected: __smatch_type_rl(type, \"string\")");
601 return 0;
602 }
603 call_results_to_rl(call, type, two->string->data, rl);
604 return 1;
605 }
606
print_left_right(struct sm_state * sm)607 static void print_left_right(struct sm_state *sm)
608 {
609 if (!sm)
610 return;
611 if (!sm->left && !sm->right)
612 return;
613
614 sm_printf("[ ");
615 if (sm->left)
616 sm_printf("(%d: %s->'%s')", get_stree_id(sm->left->pool), sm->left->name, sm->left->state->name);
617 else
618 sm_printf(" - ");
619
620
621 print_left_right(sm->left);
622
623 if (sm->right)
624 sm_printf("(%d: %s->'%s')", get_stree_id(sm->right->pool), sm->right->name, sm->right->state->name);
625 else
626 sm_printf(" - ");
627
628 print_left_right(sm->right);
629 }
630
match_print_merge_tree(const char * fn,struct expression * expr,void * info)631 static void match_print_merge_tree(const char *fn, struct expression *expr, void *info)
632 {
633 struct sm_state *sm;
634 struct expression *arg;
635 char *name;
636
637 arg = get_argument_from_call_expr(expr->args, 0);
638 name = expr_to_str(arg);
639
640 sm = get_sm_state_expr(SMATCH_EXTRA, arg);
641 if (!sm) {
642 sm_msg("no sm state for '%s'", name);
643 goto free;
644 }
645
646 sm_prefix();
647 sm_printf("merge tree: %s -> %s", name, sm->state->name);
648 print_left_right(sm);
649 sm_printf("\n");
650
651 free:
652 free_string(name);
653 }
654
match_print_stree_id(const char * fn,struct expression * expr,void * info)655 static void match_print_stree_id(const char *fn, struct expression *expr, void *info)
656 {
657 sm_msg("stree_id %d", __stree_id);
658 }
659
match_bits(const char * fn,struct expression * expr,void * _unused)660 static void match_bits(const char *fn, struct expression *expr, void *_unused)
661 {
662 struct expression *arg;
663 struct bit_info *info;
664 char *name;
665
666 arg = get_argument_from_call_expr(expr->args, 0);
667 name = expr_to_str(arg);
668
669 info = get_bit_info(arg);
670
671 sm_msg("bit info '%s': definitely set 0x%llx. possibly set 0x%llx.",
672 name, info->set, info->possible);
673 }
674
match_mtag(const char * fn,struct expression * expr,void * info)675 static void match_mtag(const char *fn, struct expression *expr, void *info)
676 {
677 struct expression *arg;
678 char *name;
679 mtag_t tag = 0;
680 int offset = 0;
681
682 arg = get_argument_from_call_expr(expr->args, 0);
683 name = expr_to_str(arg);
684 expr_to_mtag_offset(arg, &tag, &offset);
685 sm_msg("mtag: '%s' => tag: %llu %d", name, tag, offset);
686 free_string(name);
687 }
688
match_mtag_data_offset(const char * fn,struct expression * expr,void * info)689 static void match_mtag_data_offset(const char *fn, struct expression *expr, void *info)
690 {
691 struct expression *arg;
692 char *name;
693 mtag_t tag = 0;
694 int offset = -1;
695
696 arg = get_argument_from_call_expr(expr->args, 0);
697 name = expr_to_str(arg);
698 expr_to_mtag_offset(arg, &tag, &offset);
699 sm_msg("mtag: '%s' => tag: %lld, offset: %d", name, tag, offset);
700 free_string(name);
701 }
702
match_container(const char * fn,struct expression * expr,void * info)703 static void match_container(const char *fn, struct expression *expr, void *info)
704 {
705 struct expression *container, *x;
706 char *cont, *name, *str;
707
708 container = get_argument_from_call_expr(expr->args, 0);
709 x = get_argument_from_call_expr(expr->args, 1);
710
711 str = get_container_name(container, x);
712 cont = expr_to_str(container);
713 name = expr_to_str(x);
714 sm_msg("container: '%s' vs '%s' --> '%s'", cont, name, str);
715 free_string(cont);
716 free_string(name);
717 }
718
match_expr(const char * fn,struct expression * expr,void * info)719 static void match_expr(const char *fn, struct expression *expr, void *info)
720 {
721 struct expression *arg, *str, *new;
722 char *name, *new_name;
723
724 str = get_argument_from_call_expr(expr->args, 0);
725 arg = get_argument_from_call_expr(expr->args, 1);
726 if (!arg || !str)
727 return;
728
729 if (str->type != EXPR_STRING)
730 return;
731
732 new = gen_expression_from_key(arg, str->string->data);
733 name = expr_to_str(arg);
734 new_name = expr_to_str(new);
735
736 sm_msg("str = '%s', arg = '%s' expr = '%s'", str->string->data, name, new_name);
737
738 free_string(new_name);
739 free_string(name);
740 }
match_state_count(const char * fn,struct expression * expr,void * info)741 static void match_state_count(const char *fn, struct expression *expr, void *info)
742 {
743 sm_msg("state_count = %d\n", sm_state_counter);
744 }
745
match_mem(const char * fn,struct expression * expr,void * info)746 static void match_mem(const char *fn, struct expression *expr, void *info)
747 {
748 show_sname_alloc();
749 show_data_range_alloc();
750 show_rl_ptrlist_alloc();
751 show_ptrlist_alloc();
752 sm_msg("%lu pools", get_pool_count());
753 sm_msg("%d strees", unfree_stree);
754 show_smatch_state_alloc();
755 show_sm_state_alloc();
756 }
757
match_exit(const char * fn,struct expression * expr,void * info)758 static void match_exit(const char *fn, struct expression *expr, void *info)
759 {
760 exit(0);
761 }
762
763 static struct stree *old_stree;
trace_var(struct statement * stmt)764 static void trace_var(struct statement *stmt)
765 {
766 struct sm_state *sm, *old;
767 int printed = 0;
768
769 if (!trace_variable)
770 return;
771 if (__inline_fn)
772 return;
773
774 FOR_EACH_SM(__get_cur_stree(), sm) {
775 if (strcmp(sm->name, trace_variable) != 0)
776 continue;
777 old = get_sm_state_stree(old_stree, sm->owner, sm->name, sm->sym);
778 if (old && old->state == sm->state)
779 continue;
780 sm_msg("[%d] %s '%s': '%s' => '%s'", stmt->type,
781 check_name(sm->owner),
782 sm->name, old ? old->state->name : "<none>", sm->state->name);
783 printed = 1;
784 } END_FOR_EACH_SM(sm);
785
786 if (printed) {
787 free_stree(&old_stree);
788 old_stree = clone_stree(__get_cur_stree());
789 }
790 }
791
free_old_stree(struct symbol * sym)792 static void free_old_stree(struct symbol *sym)
793 {
794 free_stree(&old_stree);
795 }
796
check_debug(int id)797 void check_debug(int id)
798 {
799 my_id = id;
800 add_function_hook("__smatch_about", &match_about, NULL);
801 add_function_hook("__smatch_all_values", &match_all_values, NULL);
802 add_function_hook("__smatch_state", &match_state, NULL);
803 add_function_hook("__smatch_states", &match_states, NULL);
804 add_function_hook("__smatch_value", &match_print_value, NULL);
805 add_function_hook("__smatch_known", &match_print_known, NULL);
806 add_function_hook("__smatch_implied", &match_print_implied, NULL);
807 add_function_hook("__smatch_implied_min", &match_print_implied_min, NULL);
808 add_function_hook("__smatch_implied_max", &match_print_implied_max, NULL);
809 add_function_hook("__smatch_user_rl", &match_user_rl, NULL);
810 add_function_hook("__smatch_capped", &match_capped, NULL);
811 add_function_hook("__smatch_hard_max", &match_print_hard_max, NULL);
812 add_function_hook("__smatch_fuzzy_max", &match_print_fuzzy_max, NULL);
813 add_function_hook("__smatch_absolute", &match_print_absolute, NULL);
814 add_function_hook("__smatch_absolute_min", &match_print_absolute_min, NULL);
815 add_function_hook("__smatch_absolute_max", &match_print_absolute_max, NULL);
816 add_function_hook("__smatch_real_absolute", &match_real_absolute, NULL);
817 add_function_hook("__smatch_sval_info", &match_sval_info, NULL);
818 add_function_hook("__smatch_member_name", &match_member_name, NULL);
819 add_function_hook("__smatch_possible", &match_possible, NULL);
820 add_function_hook("__smatch_cur_stree", &match_cur_stree, NULL);
821 add_function_hook("__smatch_strlen", &match_strlen, NULL);
822 add_function_hook("__smatch_buf_size", &match_buf_size, NULL);
823 add_function_hook("__smatch_note", &match_note, NULL);
824 add_function_hook("__smatch_dump_related", &match_dump_related, NULL);
825 add_function_hook("__smatch_compare", &match_compare, NULL);
826 add_function_hook("__smatch_debug_on", &match_debug_on, NULL);
827 add_function_hook("__smatch_debug_check", &match_debug_check, NULL);
828 add_function_hook("__smatch_debug_off", &match_debug_off, NULL);
829 add_function_hook("__smatch_local_debug_on", &match_local_debug_on, NULL);
830 add_function_hook("__smatch_local_debug_off", &match_local_debug_off, NULL);
831 add_function_hook("__smatch_debug_db_on", &match_debug_db_on, NULL);
832 add_function_hook("__smatch_debug_db_off", &match_debug_db_off, NULL);
833 add_function_hook("__smatch_intersection", &match_intersection, NULL);
834 add_function_hook("__smatch_type", &match_type, NULL);
835 add_implied_return_hook("__smatch_type_rl_helper", &match_type_rl_return, NULL);
836 add_function_hook("__smatch_merge_tree", &match_print_merge_tree, NULL);
837 add_function_hook("__smatch_stree_id", &match_print_stree_id, NULL);
838 add_function_hook("__smatch_bits", &match_bits, NULL);
839 add_function_hook("__smatch_mtag", &match_mtag, NULL);
840 add_function_hook("__smatch_mtag_data", &match_mtag_data_offset, NULL);
841 add_function_hook("__smatch_expr", &match_expr, NULL);
842 add_function_hook("__smatch_state_count", &match_state_count, NULL);
843 add_function_hook("__smatch_mem", &match_mem, NULL);
844 add_function_hook("__smatch_exit", &match_exit, NULL);
845 add_function_hook("__smatch_container", &match_container, NULL);
846
847 add_hook(free_old_stree, AFTER_FUNC_HOOK);
848 add_hook(trace_var, STMT_HOOK_AFTER);
849 }
850