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 DECLARE_PTR_LIST(sval_list
, sval_t
);
37 static struct sval_list
*num_list
;
38 static struct string_list
*op_list
;
40 static void push_val(sval_t sval
)
44 p
= malloc(sizeof(*p
));
46 add_ptr_list(&num_list
, p
);
49 static sval_t
pop_val(void)
55 sm_msg("internal bug: %s popping empty list", __func__
);
56 ret
.type
= &llong_ctype
;
60 p
= last_ptr_list((struct ptr_list
*)num_list
);
61 delete_ptr_list_last((struct ptr_list
**)&num_list
);
68 static void push_op(char c
)
74 add_ptr_list(&op_list
, p
);
77 static char pop_op(void)
83 sm_msg("internal smatch error %s", __func__
);
87 p
= last_ptr_list((struct ptr_list
*)op_list
);
89 delete_ptr_list_last((struct ptr_list
**)&op_list
);
96 static int op_precedence(char c
)
110 static int top_op_precedence(void)
117 p
= last_ptr_list((struct ptr_list
*)op_list
);
118 return op_precedence(p
[0]);
121 static void pop_until(char c
)
127 while (top_op_precedence() && op_precedence(c
) <= top_op_precedence()) {
131 res
= sval_binop(left
, op
, right
);
136 static void discard_stacks(void)
144 static int get_implied_param(struct expression
*call
, int param
, sval_t
*sval
)
146 struct expression
*arg
;
148 arg
= get_argument_from_call_expr(call
->args
, param
);
149 return get_implied_value(arg
, sval
);
152 static int read_number(struct expression
*call
, char *p
, char **end
, sval_t
*sval
)
161 param
= strtol(p
, &p
, 10);
162 if (!get_implied_param(call
, param
, sval
))
166 sval
->type
= &llong_ctype
;
167 sval
->value
= strtoll(p
, end
, 10);
174 static char *read_op(char *p
)
190 int parse_call_math(struct expression
*call
, char *math
, sval_t
*sval
)
195 /* try to implement shunting yard algorithm. */
200 sm_msg("parsing %s", c
);
202 /* read a number and push it onto the number stack */
203 if (!read_number(call
, c
, &c
, &tmp
))
208 sm_msg("val = %s remaining = %s", sval_to_str(tmp
), c
);
212 if (*c
== ']' && *(c
+ 1) == '\0')
220 sm_msg("op = %c remaining = %s", *c
, c
);
235 int parse_call_math_rl(struct expression
*call
, char *math
, struct range_list
**rl
)
237 struct expression
*arg
;
242 if (parse_call_math(call
, math
, &sval
)) {
243 *rl
= alloc_rl(sval
, sval
);
250 param
= strtoll(c
, &c
, 10);
253 arg
= get_argument_from_call_expr(call
->args
, param
);
254 return get_implied_rl(arg
, rl
);
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_expr_helper(char *buf
, int remaining
, struct expression
*expr
)
300 if (expr
->type
== EXPR_BINOP
) {
301 ret
= format_expr_helper(cur
, remaining
, expr
->left
);
309 ret
= snprintf(cur
, remaining
, " %s ", show_special(expr
->op
));
315 ret
= format_expr_helper(cur
, remaining
, expr
->right
);
325 arg
= get_arg_number(expr
);
327 ret
= snprintf(cur
, remaining
, "$%d", arg
);
334 if (get_implied_value(expr
, &sval
)) {
335 ret
= snprintf(cur
, remaining
, "%s", sval_to_str(sval
));
345 static char *format_expr(struct expression
*expr
)
350 ret
= format_expr_helper(buf
, sizeof(buf
), expr
);
354 return alloc_sname(buf
);
357 char *get_value_in_terms_of_parameter_math(struct expression
*expr
)
359 struct expression
*tmp
;
363 tmp
= get_assigned_expr(expr
);
367 ret
= format_expr_helper(buf
, sizeof(buf
), expr
);
371 return alloc_sname(buf
);
374 char *get_value_in_terms_of_parameter_math_var_sym(const char *name
, struct symbol
*sym
)
376 struct expression
*expr
;
380 expr
= get_assigned_expr_name_sym(name
, sym
);
384 ret
= format_expr_helper(buf
, sizeof(buf
), expr
);
388 return alloc_sname(buf
);
392 static void match_alloc(const char *fn
, struct expression
*expr
, void *_size_arg
)
394 int size_arg
= PTR_INT(_size_arg
);
395 struct expression
*right
;
396 struct expression
*size_expr
;
399 right
= strip_expr(expr
->right
);
400 size_expr
= get_argument_from_call_expr(right
->args
, size_arg
);
402 sname
= format_expr(size_expr
);
405 set_state_expr(my_id
, expr
->left
, alloc_state_sname(sname
));
408 static char *swap_format(struct expression
*call
, char *format
)
413 struct expression
*arg
;
418 if (format
[0] == '$' && format
[2] == '\0') {
419 param
= strtol(format
+ 1, NULL
, 10);
420 arg
= get_argument_from_call_expr(call
->args
, param
);
423 return format_expr(arg
);
432 param
= strtol(p
, &p
, 10);
436 arg
= get_argument_from_call_expr(call
->args
, param
);
439 param
= get_arg_number(arg
);
441 ret
= snprintf(out
, buf
+ sizeof(buf
) - out
, "$%ld", param
);
443 if (out
>= buf
+ sizeof(buf
))
445 } else if (get_implied_value(arg
, &sval
)) {
446 ret
= snprintf(out
, buf
+ sizeof(buf
) - out
, "%s", sval_to_str(sval
));
448 if (out
>= buf
+ sizeof(buf
))
460 return alloc_sname(buf
);
463 static char *buf_size_recipe
;
464 static int db_buf_size_callback(void *unused
, int argc
, char **argv
, char **azColName
)
469 if (!buf_size_recipe
)
470 buf_size_recipe
= alloc_sname(argv
[0]);
471 else if (strcmp(buf_size_recipe
, argv
[0]) != 0)
472 buf_size_recipe
= alloc_sname("invalid");
476 static char *get_allocation_recipe_from_call(struct expression
*expr
)
479 static char sql_filter
[1024];
482 if (is_fake_call(expr
))
484 expr
= strip_expr(expr
);
485 if (expr
->fn
->type
!= EXPR_SYMBOL
)
487 sym
= expr
->fn
->symbol
;
491 for (i
= 0; i
< ARRAY_SIZE(alloc_functions
); i
++) {
492 if (strcmp(sym
->ident
->name
, alloc_functions
[i
].func
) == 0) {
495 snprintf(buf
, sizeof(buf
), "$%d", alloc_functions
[i
].param
);
496 buf_size_recipe
= alloc_sname(buf
);
497 return swap_format(expr
, buf_size_recipe
);
501 if (sym
->ctype
.modifiers
& MOD_STATIC
) {
502 snprintf(sql_filter
, 1024, "file = '%s' and function = '%s';",
503 get_filename(), sym
->ident
->name
);
505 snprintf(sql_filter
, 1024, "function = '%s' and static = 0;",
509 buf_size_recipe
= NULL
;
510 run_sql(db_buf_size_callback
, NULL
,
511 "select value from return_states where type=%d and %s",
512 BUF_SIZE
, sql_filter
);
513 if (!buf_size_recipe
|| strcmp(buf_size_recipe
, "invalid") == 0)
515 return swap_format(expr
, buf_size_recipe
);
518 static void match_call_assignment(struct expression
*expr
)
522 sname
= get_allocation_recipe_from_call(expr
->right
);
525 set_state_expr(my_id
, expr
->left
, alloc_state_sname(sname
));
528 static void match_returns_call(int return_id
, char *return_ranges
, struct expression
*call
)
532 sname
= get_allocation_recipe_from_call(call
);
534 sm_msg("sname = %s", sname
);
538 sql_insert_return_states(return_id
, return_ranges
, BUF_SIZE
, -1, "",
542 static void print_returned_allocations(int return_id
, char *return_ranges
, struct expression
*expr
)
544 struct smatch_state
*state
;
548 expr
= strip_expr(expr
);
552 if (expr
->type
== EXPR_CALL
) {
553 match_returns_call(return_id
, return_ranges
, expr
);
557 name
= expr_to_var_sym(expr
, &sym
);
561 state
= get_state(my_id
, name
, sym
);
562 if (!state
|| !state
->data
)
565 sql_insert_return_states(return_id
, return_ranges
, BUF_SIZE
, -1, "",
571 void register_parse_call_math(int id
)
577 for (i
= 0; i
< ARRAY_SIZE(alloc_functions
); i
++)
578 add_function_assign_hook(alloc_functions
[i
].func
, &match_alloc
,
579 INT_PTR(alloc_functions
[i
].param
));
580 add_hook(&match_call_assignment
, CALL_ASSIGNMENT_HOOK
);
581 add_split_return_callback(print_returned_allocations
);