xref: /illumos-gate/usr/src/tools/smatch/src/check_debug.c (revision 6523a3aa7f325d64841382707603be7a86e68147)
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