2 * Copyright (C) 2012 Oracle.
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.
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.
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
19 #include "smatch_slist.h"
20 #include "smatch_extra.h"
27 } alloc_functions
[] = {
32 {"__vmalloc_node", 0},
35 static struct range_list_stack
*rl_stack
;
36 static struct string_list
*op_list
;
38 static void push_op(char c
)
44 add_ptr_list(&op_list
, p
);
47 static char pop_op(void)
53 sm_msg("internal smatch error %s", __func__
);
57 p
= last_ptr_list((struct ptr_list
*)op_list
);
59 delete_ptr_list_last((struct ptr_list
**)&op_list
);
66 static int op_precedence(char c
)
80 static int top_op_precedence(void)
87 p
= last_ptr_list((struct ptr_list
*)op_list
);
88 return op_precedence(p
[0]);
91 static void rl_pop_until(char c
)
94 struct range_list
*left
, *right
;
95 struct range_list
*res
;
97 while (top_op_precedence() && op_precedence(c
) <= top_op_precedence()) {
99 right
= pop_rl(&rl_stack
);
100 left
= pop_rl(&rl_stack
);
101 res
= rl_binop(left
, op
, right
);
103 res
= alloc_whole_rl(&llong_ctype
);
104 push_rl(&rl_stack
, res
);
108 static void rl_discard_stacks(void)
116 static int read_rl_from_var(struct expression
*call
, char *p
, char **end
, struct range_list
**rl
)
118 struct expression
*arg
;
119 struct smatch_state
*state
;
127 param
= strtol(p
, &p
, 10);
129 arg
= get_argument_from_call_expr(call
->args
, param
);
133 if (*p
!= '-' && *p
!= '.') {
134 get_absolute_rl(arg
, rl
);
139 *end
= strchr(p
, ' ');
141 if (arg
->type
== EXPR_PREOP
&& arg
->op
== '&') {
142 arg
= strip_expr(arg
->unop
);
150 name
= expr_to_var_sym(arg
, &sym
);
153 snprintf(buf
, sizeof(buf
), "%s%s", name
, star
? "->" : ".");
156 if (*end
- p
+ strlen(buf
) >= sizeof(buf
))
158 strncat(buf
, p
, *end
- p
);
160 state
= get_state(SMATCH_EXTRA
, buf
, sym
);
163 *rl
= estate_rl(state
);
167 static int read_var_num(struct expression
*call
, char *p
, char **end
, struct range_list
**rl
)
175 return read_rl_from_var(call
, p
, end
, rl
);
177 sval
.type
= &llong_ctype
;
178 sval
.value
= strtoll(p
, end
, 10);
181 *rl
= alloc_rl(sval
, sval
);
185 static char *read_op(char *p
)
201 int parse_call_math_rl(struct expression
*call
, char *math
, struct range_list
**rl
)
203 struct range_list
*tmp
;
206 /* try to implement shunting yard algorithm. */
211 sm_msg("parsing %s", c
);
213 /* read a number and push it onto the number stack */
214 if (!read_var_num(call
, c
, &c
, &tmp
))
216 push_rl(&rl_stack
, tmp
);
219 sm_msg("val = %s remaining = %s", show_rl(tmp
), c
);
223 if (*c
== ']' && *(c
+ 1) == '\0')
231 sm_msg("op = %c remaining = %s", *c
, c
);
239 *rl
= pop_rl(&rl_stack
);
246 int parse_call_math(struct expression
*call
, char *math
, sval_t
*sval
)
248 struct range_list
*rl
;
250 if (!parse_call_math_rl(call
, math
, &rl
))
252 if (!rl_to_sval(rl
, sval
))
257 static struct smatch_state
*alloc_state_sname(char *sname
)
259 struct smatch_state
*state
;
261 state
= __alloc_smatch_state(0);
263 state
->data
= INT_PTR(1);
267 static int get_arg_number(struct expression
*expr
)
273 expr
= strip_expr(expr
);
274 if (expr
->type
!= EXPR_SYMBOL
)
279 FOR_EACH_PTR(cur_func_sym
->ctype
.base_type
->arguments
, arg
) {
283 } END_FOR_EACH_PTR(arg
);
288 static int format_name_sym_helper(char *buf
, int remaining
, char *name
, struct symbol
*sym
)
295 if (!name
|| !sym
|| !sym
->ident
)
297 arg
= get_param_num_from_sym(sym
);
300 if (param_was_set_var_sym(name
, sym
))
303 param_name
= sym
->ident
->name
;
304 name_len
= strlen(param_name
);
306 if (name
[name_len
] == '\0')
307 ret
= snprintf(buf
, remaining
, "$%d", arg
);
308 else if (name
[name_len
] == '-')
309 ret
= snprintf(buf
, remaining
, "$%d%s", arg
, name
+ name_len
);
324 static int format_variable_helper(char *buf
, int remaining
, struct expression
*expr
)
329 name
= expr_to_var_sym(expr
, &sym
);
330 return format_name_sym_helper(buf
, remaining
, name
, sym
);
333 static int format_call_to_param_mapping(char *buf
, int remaining
, struct expression
*expr
)
338 name
= map_call_to_param_name_sym(expr
, &sym
);
339 return format_name_sym_helper(buf
, remaining
, name
, sym
);
342 static int format_expr_helper(char *buf
, int remaining
, struct expression
*expr
)
353 if (expr
->type
== EXPR_BINOP
) {
354 ret
= format_expr_helper(cur
, remaining
, expr
->left
);
362 ret
= snprintf(cur
, remaining
, " %s ", show_special(expr
->op
));
368 ret
= format_expr_helper(cur
, remaining
, expr
->right
);
378 if (get_implied_value(expr
, &sval
)) {
379 ret
= snprintf(cur
, remaining
, "%s", sval_to_str(sval
));
386 if (expr
->type
== EXPR_CALL
)
387 return format_call_to_param_mapping(cur
, remaining
, expr
);
389 return format_variable_helper(cur
, remaining
, expr
);
392 static char *format_expr(struct expression
*expr
)
397 ret
= format_expr_helper(buf
, sizeof(buf
), expr
);
401 return alloc_sname(buf
);
404 char *get_value_in_terms_of_parameter_math(struct expression
*expr
)
406 struct expression
*tmp
;
411 tmp
= get_assigned_expr(expr
);
415 if (get_implied_value(expr
, &dummy
))
418 ret
= format_expr_helper(buf
, sizeof(buf
), expr
);
422 return alloc_sname(buf
);
425 char *get_value_in_terms_of_parameter_math_var_sym(const char *name
, struct symbol
*sym
)
427 struct expression
*expr
;
431 expr
= get_assigned_expr_name_sym(name
, sym
);
435 ret
= format_expr_helper(buf
, sizeof(buf
), expr
);
439 return alloc_sname(buf
);
443 static void match_alloc(const char *fn
, struct expression
*expr
, void *_size_arg
)
445 int size_arg
= PTR_INT(_size_arg
);
446 struct expression
*right
;
447 struct expression
*size_expr
;
450 right
= strip_expr(expr
->right
);
451 size_expr
= get_argument_from_call_expr(right
->args
, size_arg
);
453 sname
= format_expr(size_expr
);
456 set_state_expr(my_id
, expr
->left
, alloc_state_sname(sname
));
459 static char *swap_format(struct expression
*call
, char *format
)
464 struct expression
*arg
;
469 if (format
[0] == '$' && format
[2] == '\0') {
470 param
= strtol(format
+ 1, NULL
, 10);
471 arg
= get_argument_from_call_expr(call
->args
, param
);
474 return format_expr(arg
);
483 param
= strtol(p
, &p
, 10);
484 arg
= get_argument_from_call_expr(call
->args
, param
);
487 param
= get_arg_number(arg
);
489 ret
= snprintf(out
, buf
+ sizeof(buf
) - out
, "$%ld", param
);
491 if (out
>= buf
+ sizeof(buf
))
493 } else if (get_implied_value(arg
, &sval
)) {
494 ret
= snprintf(out
, buf
+ sizeof(buf
) - out
, "%s", sval_to_str(sval
));
496 if (out
>= buf
+ sizeof(buf
))
509 return alloc_sname(buf
);
512 static char *buf_size_recipe
;
513 static int db_buf_size_callback(void *unused
, int argc
, char **argv
, char **azColName
)
518 if (!buf_size_recipe
)
519 buf_size_recipe
= alloc_sname(argv
[0]);
520 else if (strcmp(buf_size_recipe
, argv
[0]) != 0)
521 buf_size_recipe
= alloc_sname("invalid");
525 static char *get_allocation_recipe_from_call(struct expression
*expr
)
528 static char sql_filter
[1024];
531 if (is_fake_call(expr
))
533 expr
= strip_expr(expr
);
534 if (expr
->fn
->type
!= EXPR_SYMBOL
)
536 sym
= expr
->fn
->symbol
;
540 for (i
= 0; i
< ARRAY_SIZE(alloc_functions
); i
++) {
541 if (strcmp(sym
->ident
->name
, alloc_functions
[i
].func
) == 0) {
544 snprintf(buf
, sizeof(buf
), "$%d", alloc_functions
[i
].param
);
545 buf_size_recipe
= alloc_sname(buf
);
546 return swap_format(expr
, buf_size_recipe
);
550 if (sym
->ctype
.modifiers
& MOD_STATIC
) {
551 snprintf(sql_filter
, 1024, "file = '%s' and function = '%s';",
552 get_filename(), sym
->ident
->name
);
554 snprintf(sql_filter
, 1024, "function = '%s' and static = 0;",
558 buf_size_recipe
= NULL
;
559 run_sql(db_buf_size_callback
, NULL
,
560 "select value from return_states where type=%d and %s",
561 BUF_SIZE
, sql_filter
);
562 if (!buf_size_recipe
|| strcmp(buf_size_recipe
, "invalid") == 0)
564 return swap_format(expr
, buf_size_recipe
);
567 static void match_call_assignment(struct expression
*expr
)
571 sname
= get_allocation_recipe_from_call(expr
->right
);
574 set_state_expr(my_id
, expr
->left
, alloc_state_sname(sname
));
577 static void match_returns_call(int return_id
, char *return_ranges
, struct expression
*call
)
581 sname
= get_allocation_recipe_from_call(call
);
583 sm_msg("sname = %s", sname
);
587 sql_insert_return_states(return_id
, return_ranges
, BUF_SIZE
, -1, "",
591 static void print_returned_allocations(int return_id
, char *return_ranges
, struct expression
*expr
)
593 struct smatch_state
*state
;
597 expr
= strip_expr(expr
);
601 if (expr
->type
== EXPR_CALL
) {
602 match_returns_call(return_id
, return_ranges
, expr
);
606 name
= expr_to_var_sym(expr
, &sym
);
610 state
= get_state(my_id
, name
, sym
);
611 if (!state
|| !state
->data
)
614 sql_insert_return_states(return_id
, return_ranges
, BUF_SIZE
, -1, "",
620 void register_parse_call_math(int id
)
626 for (i
= 0; i
< ARRAY_SIZE(alloc_functions
); i
++)
627 add_function_assign_hook(alloc_functions
[i
].func
, &match_alloc
,
628 INT_PTR(alloc_functions
[i
].param
));
629 add_hook(&match_call_assignment
, CALL_ASSIGNMENT_HOOK
);
630 add_split_return_callback(print_returned_allocations
);