2 * Copyright (C) 2010 Dan Carpenter.
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
22 #include "smatch_slist.h"
23 #include "smatch_extra.h"
24 #include "smatch_function_hashtable.h"
26 #define UNKNOWN_SIZE -1
28 static int my_size_id
;
30 static DEFINE_HASHTABLE_INSERT(insert_func
, char, int);
31 static DEFINE_HASHTABLE_SEARCH(search_func
, char, int);
32 static struct hashtable
*allocation_funcs
;
34 static char *get_fn_name(struct expression
*expr
)
36 if (expr
->type
!= EXPR_CALL
)
38 if (expr
->fn
->type
!= EXPR_SYMBOL
)
40 return expr_to_var(expr
->fn
);
43 static int is_allocation_function(struct expression
*expr
)
48 func
= get_fn_name(expr
);
51 if (search_func(allocation_funcs
, func
))
57 static void add_allocation_function(const char *func
, void *call_back
, int param
)
59 insert_func(allocation_funcs
, (char *)func
, (int *)1);
60 add_function_assign_hook(func
, call_back
, INT_PTR(param
));
63 static struct smatch_state
*size_to_estate(int size
)
67 sval
.type
= &int_ctype
;
70 return alloc_estate_sval(sval
);
73 static struct range_list
*size_to_rl(int size
)
77 sval
.type
= &int_ctype
;
80 return alloc_rl(sval
, sval
);
83 static struct smatch_state
*unmatched_size_state(struct sm_state
*sm
)
85 return size_to_estate(UNKNOWN_SIZE
);
88 static void set_size_undefined(struct sm_state
*sm
, struct expression
*mod_expr
)
90 set_state(sm
->owner
, sm
->name
, sm
->sym
, size_to_estate(UNKNOWN_SIZE
));
93 static struct smatch_state
*merge_size_func(struct smatch_state
*s1
, struct smatch_state
*s2
)
95 return merge_estates(s1
, s2
);
98 void set_param_buf_size(const char *name
, struct symbol
*sym
, char *key
, char *value
)
100 struct range_list
*rl
= NULL
;
101 struct smatch_state
*state
;
104 if (strncmp(key
, "$", 1) != 0)
107 snprintf(fullname
, 256, "%s%s", name
, key
+ 1);
109 str_to_rl(&int_ctype
, value
, &rl
);
110 if (!rl
|| is_whole_rl(rl
))
112 state
= alloc_estate_rl(rl
);
113 set_state(my_size_id
, fullname
, sym
, state
);
116 static int bytes_per_element(struct expression
*expr
)
122 if (expr
->type
== EXPR_STRING
)
123 return expr
->wide
+ 1;
124 if (expr
->type
== EXPR_PREOP
&& expr
->op
== '&') {
125 type
= get_type(expr
->unop
);
126 if (type
&& type
->type
== SYM_ARRAY
)
129 type
= get_type(expr
);
133 if (type
->type
!= SYM_PTR
&& type
->type
!= SYM_ARRAY
)
136 type
= get_base_type(type
);
137 return type_bytes(type
);
140 int bytes_to_elements(struct expression
*expr
, int bytes
)
144 bpe
= bytes_per_element(expr
);
150 static int elements_to_bytes(struct expression
*expr
, int elements
)
154 bpe
= bytes_per_element(expr
);
155 return elements
* bpe
;
158 static int get_initializer_size(struct expression
*expr
)
160 switch (expr
->type
) {
162 return expr
->string
->length
* (expr
->wide
+ 1);
163 case EXPR_INITIALIZER
: {
164 struct expression
*tmp
;
167 FOR_EACH_PTR(expr
->expr_list
, tmp
) {
168 if (tmp
->type
== EXPR_INDEX
) {
169 if (tmp
->idx_to
>= i
)
176 } END_FOR_EACH_PTR(tmp
);
180 return get_array_size(expr
);
185 static struct range_list
*db_size_rl
;
186 static int db_size_callback(void *unused
, int argc
, char **argv
, char **azColName
)
188 struct range_list
*tmp
= NULL
;
191 str_to_rl(&int_ctype
, argv
[0], &db_size_rl
);
193 str_to_rl(&int_ctype
, argv
[0], &tmp
);
194 db_size_rl
= rl_union(db_size_rl
, tmp
);
199 static struct expression
*cached_type_expr
, *cached_sym_expr
;
200 static struct range_list
*cached_type_rl
, *cached_sym_rl
;
202 static void match_clear_cache(struct symbol
*sym
)
204 cached_type_expr
= NULL
;
205 cached_type_rl
= NULL
;
206 cached_sym_expr
= NULL
;
207 cached_sym_rl
= NULL
;
210 static struct range_list
*size_from_db_type(struct expression
*expr
)
212 int this_file_only
= 0;
215 name
= get_member_name(expr
);
216 if (!name
&& is_static(expr
)) {
217 name
= expr_to_var(expr
);
223 if (expr
== cached_type_expr
)
224 return clone_rl(cached_type_rl
);
225 cached_type_expr
= expr
;
226 cached_type_rl
= NULL
;
228 if (this_file_only
) {
230 run_sql(db_size_callback
, NULL
,
231 "select size from function_type_size where type = '%s' and file = %d;",
232 name
, get_file_id());
233 cached_type_rl
= clone_rl(db_size_rl
);
238 run_sql(db_size_callback
, NULL
,
239 "select size from type_size where type = '%s';",
241 cached_type_rl
= clone_rl(db_size_rl
);
245 static struct range_list
*size_from_db_symbol(struct expression
*expr
)
249 if (expr
->type
!= EXPR_SYMBOL
)
252 if (!sym
|| !sym
->ident
||
253 !(sym
->ctype
.modifiers
& MOD_TOPLEVEL
) ||
254 sym
->ctype
.modifiers
& MOD_STATIC
)
257 if (expr
== cached_sym_expr
)
258 return clone_rl(cached_sym_rl
);
259 cached_sym_expr
= expr
;
260 cached_sym_rl
= NULL
;
263 run_sql(db_size_callback
, NULL
,
264 "select value from data_info where file = 0 and data = '%s' and type = %d;",
265 sym
->ident
->name
, BUF_SIZE
);
266 cached_sym_rl
= clone_rl(db_size_rl
);
270 static struct range_list
*size_from_db(struct expression
*expr
)
272 struct range_list
*rl
;
274 rl
= size_from_db_symbol(expr
);
277 return size_from_db_type(expr
);
280 static void db_returns_buf_size(struct expression
*expr
, int param
, char *unused
, char *math
)
282 struct expression
*call
;
283 struct range_list
*rl
;
286 if (expr
->type
!= EXPR_ASSIGNMENT
)
288 call
= strip_expr(expr
->right
);
290 call_results_to_rl(call
, &int_ctype
, math
, &rl
);
291 rl
= cast_rl(&int_ctype
, rl
);
292 if (rl_to_sval(rl
, &sval
) && sval
.value
== 0)
294 set_state_expr(my_size_id
, expr
->left
, alloc_estate_rl(rl
));
297 static int get_real_array_size_from_type(struct symbol
*type
)
303 if (!type
|| type
->type
!= SYM_ARRAY
)
306 if (!get_implied_value(type
->array_size
, &sval
))
312 int get_real_array_size(struct expression
*expr
)
316 if (expr
->type
== EXPR_PREOP
&& expr
->op
== '&')
318 if (expr
->type
== EXPR_BINOP
) /* array elements foo[5] */
320 return get_real_array_size_from_type(get_type(expr
));
323 static int get_size_from_initializer(struct expression
*expr
)
325 if (expr
->type
!= EXPR_SYMBOL
|| !expr
->symbol
|| !expr
->symbol
->initializer
)
327 if (expr
->symbol
->initializer
== expr
) /* int a = a; */
329 return get_initializer_size(expr
->symbol
->initializer
);
332 static struct range_list
*get_stored_size_bytes(struct expression
*expr
)
334 struct smatch_state
*state
;
336 state
= get_state_expr(my_size_id
, expr
);
339 return estate_rl(state
);
342 static int get_bytes_from_address(struct expression
*expr
)
347 if (expr
->type
!= EXPR_PREOP
|| expr
->op
!= '&')
349 type
= get_type(expr
);
353 if (type
->type
== SYM_PTR
)
354 type
= get_base_type(type
);
356 ret
= type_bytes(type
);
358 return 0; /* ignore char pointers */
363 static struct expression
*remove_addr_fluff(struct expression
*expr
)
365 struct expression
*tmp
;
368 expr
= strip_expr(expr
);
370 /* remove '&' and '*' operations that cancel */
371 while (expr
&& expr
->type
== EXPR_PREOP
&& expr
->op
== '&') {
372 tmp
= strip_expr(expr
->unop
);
373 if (tmp
->type
!= EXPR_PREOP
)
377 expr
= strip_expr(tmp
->unop
);
383 /* "foo + 0" is just "foo" */
384 if (expr
->type
== EXPR_BINOP
&& expr
->op
== '+' &&
385 get_value(expr
->right
, &sval
) && sval
.value
== 0)
391 static int is_last_member_of_struct(struct symbol
*sym
, struct ident
*member
)
396 if (sym
->type
!= SYM_STRUCT
)
400 FOR_EACH_PTR_REVERSE(sym
->symbol_list
, tmp
) {
401 if (i
++ || !tmp
->ident
)
403 if (tmp
->ident
== member
)
406 } END_FOR_EACH_PTR_REVERSE(tmp
);
411 int last_member_is_resizable(struct symbol
*sym
)
413 struct symbol
*last_member
;
417 if (!sym
|| sym
->type
!= SYM_STRUCT
)
420 last_member
= last_ptr_list((struct ptr_list
*)sym
->symbol_list
);
421 if (!last_member
|| !last_member
->ident
)
424 type
= get_real_base_type(last_member
);
425 if (type
->type
== SYM_STRUCT
)
426 return last_member_is_resizable(type
);
427 if (type
->type
!= SYM_ARRAY
)
430 if (!type
->array_size
)
433 if (!get_implied_value(type
->array_size
, &sval
))
436 if (sval
.value
!= 0 && sval
.value
!= 1)
442 static struct range_list
*get_stored_size_end_struct_bytes(struct expression
*expr
)
445 struct symbol
*base_sym
;
446 struct smatch_state
*state
;
451 if (expr
->type
== EXPR_BINOP
) /* array elements foo[5] */
454 if (expr
->type
== EXPR_PREOP
&& expr
->op
== '&')
455 expr
= strip_parens(expr
->unop
);
457 sym
= expr_to_sym(expr
);
458 if (!sym
|| !sym
->ident
)
460 if (!type_bytes(sym
))
462 if (sym
->type
!= SYM_NODE
)
465 base_sym
= get_real_base_type(sym
);
466 if (!base_sym
|| base_sym
->type
!= SYM_PTR
)
468 base_sym
= get_real_base_type(base_sym
);
469 if (!base_sym
|| base_sym
->type
!= SYM_STRUCT
)
472 if (!is_last_member_of_struct(base_sym
, expr
->member
))
474 if (!last_member_is_resizable(base_sym
))
477 state
= get_state(my_size_id
, sym
->ident
->name
, sym
);
478 if (!estate_rl(state
))
480 base_size
.value
= type_bytes(base_sym
) - type_bytes(get_type(expr
));
481 if (sval_cmp(estate_min(state
), base_size
) < 0)
484 return rl_binop(estate_rl(state
), '-', alloc_rl(base_size
, base_size
));
487 static int get_last_element_bytes(struct expression
*expr
)
489 struct symbol
*type
, *member
, *member_type
;
491 type
= get_type(expr
);
492 if (!type
|| type
->type
!= SYM_STRUCT
)
494 member
= last_ptr_list((struct ptr_list
*)type
->symbol_list
);
497 member_type
= get_real_base_type(member
);
500 return type_bytes(member_type
);
503 static struct range_list
*get_outer_end_struct_bytes(struct expression
*expr
)
505 struct expression
*outer
;
506 int last_element_size
;
513 * What we're checking here is for when "u.bar.baz" is a zero element
514 * array and "u" has a buffer to determine the space for baz. Like
516 * struct { struct bar bar; char buf[256]; } u;
520 if (expr
->type
== EXPR_PREOP
&& expr
->op
== '&')
521 expr
= strip_parens(expr
->unop
);
522 if (expr
->type
!= EXPR_DEREF
)
525 if (outer
->type
!= EXPR_DEREF
)
527 type
= get_type(outer
);
531 if (!is_last_member_of_struct(type
, expr
->member
))
533 if (!last_member_is_resizable(type
))
536 last_element_size
= get_last_element_bytes(outer
->deref
);
537 if (last_element_size
== 0)
539 if (type_bytes(get_type(outer
)) + last_element_size
!=
540 type_bytes(get_type(outer
->deref
)))
543 bytes
.value
= last_element_size
;
544 return alloc_rl(bytes
, bytes
);
547 static struct range_list
*alloc_int_rl(int value
)
554 return alloc_rl(sval
, sval
);
557 struct range_list
*get_array_size_bytes_rl(struct expression
*expr
)
559 struct range_list
*ret
= NULL
;
563 if (is_fake_call(expr
))
566 expr
= remove_addr_fluff(expr
);
571 if (expr
->type
== EXPR_STRING
)
572 return alloc_int_rl(expr
->string
->length
* (expr
->wide
+ 1));
574 if (expr
->type
== EXPR_BINOP
&& expr
->op
== '+') {
579 if (!get_implied_value(expr
->right
, &offset
))
581 type
= get_type(expr
->left
);
584 if (type
->type
!= SYM_ARRAY
&& type
->type
!= SYM_PTR
)
586 type
= get_real_base_type(type
);
587 bytes
= type_bytes(type
);
590 offset
.value
*= bytes
;
591 size
= get_array_size_bytes(expr
->left
);
594 return alloc_int_rl(size
- offset
.value
);
597 /* buf = malloc(1024); */
598 ret
= get_stored_size_bytes(expr
);
602 ret
= get_stored_size_end_struct_bytes(expr
);
606 ret
= get_outer_end_struct_bytes(expr
);
611 size
= get_real_array_size(expr
);
613 return alloc_int_rl(elements_to_bytes(expr
, size
));
615 /* char *foo = "BAR" */
616 size
= get_size_from_initializer(expr
);
618 return alloc_int_rl(elements_to_bytes(expr
, size
));
620 size
= get_bytes_from_address(expr
);
622 return alloc_int_rl(size
);
624 ret
= size_from_db(expr
);
625 if (rl_to_sval(ret
, &sval
) && sval
.value
== -1)
633 int get_array_size_bytes(struct expression
*expr
)
635 struct range_list
*rl
;
638 rl
= get_array_size_bytes_rl(expr
);
639 if (!rl_to_sval(rl
, &sval
))
641 if (sval
.uvalue
>= INT_MAX
)
646 int get_array_size_bytes_max(struct expression
*expr
)
648 struct range_list
*rl
;
651 rl
= get_array_size_bytes_rl(expr
);
658 if (bytes
.uvalue
>= INT_MAX
)
663 int get_array_size_bytes_min(struct expression
*expr
)
665 struct range_list
*rl
;
666 struct data_range
*range
;
668 rl
= get_array_size_bytes_rl(expr
);
672 FOR_EACH_PTR(rl
, range
) {
673 if (range
->min
.value
<= 0)
675 if (range
->max
.value
<= 0)
677 if (range
->min
.uvalue
>= INT_MAX
)
679 return range
->min
.value
;
680 } END_FOR_EACH_PTR(range
);
685 int get_array_size(struct expression
*expr
)
689 return bytes_to_elements(expr
, get_array_size_bytes_max(expr
));
692 static struct expression
*strip_ampersands(struct expression
*expr
)
696 if (expr
->type
!= EXPR_PREOP
)
700 type
= get_type(expr
->unop
);
701 if (!type
|| type
->type
!= SYM_ARRAY
)
706 static void info_record_alloction(struct expression
*buffer
, struct range_list
*rl
)
713 name
= get_member_name(buffer
);
714 if (!name
&& is_static(buffer
))
715 name
= expr_to_var(buffer
);
718 if (rl
&& !is_whole_rl(rl
))
719 sql_insert_function_type_size(name
, show_rl(rl
));
721 sql_insert_function_type_size(name
, "(-1)");
726 static void store_alloc(struct expression
*expr
, struct range_list
*rl
)
730 rl
= clone_rl(rl
); // FIXME!!!
732 rl
= size_to_rl(UNKNOWN_SIZE
);
734 if (rl_min(rl
).value
!= UNKNOWN_SIZE
||
735 rl_max(rl
).value
!= UNKNOWN_SIZE
||
736 get_state_expr(my_size_id
, expr
))
737 set_state_expr(my_size_id
, expr
, alloc_estate_rl(rl
));
739 type
= get_type(expr
);
742 if (type
->type
!= SYM_PTR
)
744 type
= get_real_base_type(type
);
747 if (type
== &void_ctype
)
749 if (type
->type
!= SYM_BASETYPE
&& type
->type
!= SYM_PTR
)
752 info_record_alloction(expr
, rl
);
755 static bool is_array_base(struct expression
*expr
)
759 type
= get_type(expr
);
760 if (type
&& type
->type
== SYM_ARRAY
)
765 static void match_array_assignment(struct expression
*expr
)
767 struct expression
*left
;
768 struct expression
*right
;
769 char *left_member
, *right_member
;
770 struct range_list
*rl
;
776 left
= strip_expr(expr
->left
);
777 right
= strip_expr(expr
->right
);
778 right
= strip_ampersands(right
);
780 if (!is_pointer(left
))
782 /* char buf[24] = "str"; */
783 if (is_array_base(left
))
785 if (is_allocation_function(right
))
788 left_member
= get_member_name(left
);
789 right_member
= get_member_name(right
);
790 if (left_member
&& right_member
&& strcmp(left_member
, right_member
) == 0) {
791 free_string(left_member
);
792 free_string(right_member
);
795 free_string(left_member
);
796 free_string(right_member
);
798 if (get_implied_value(right
, &sval
) && sval
.value
== 0) {
799 rl
= alloc_int_rl(0);
803 rl
= get_array_size_bytes_rl(right
);
804 if (!rl
&& __in_fake_assign
)
808 store_alloc(left
, rl
);
811 static void match_alloc(const char *fn
, struct expression
*expr
, void *_size_arg
)
813 int size_arg
= PTR_INT(_size_arg
);
814 struct expression
*right
;
815 struct expression
*arg
;
816 struct range_list
*rl
;
818 right
= strip_expr(expr
->right
);
819 arg
= get_argument_from_call_expr(right
->args
, size_arg
);
820 get_absolute_rl(arg
, &rl
);
821 rl
= cast_rl(&int_ctype
, rl
);
822 store_alloc(expr
->left
, rl
);
825 static void match_calloc(const char *fn
, struct expression
*expr
, void *_param
)
827 struct expression
*right
;
828 struct expression
*size
, *nr
, *mult
;
829 struct range_list
*rl
;
830 int param
= PTR_INT(_param
);
832 right
= strip_expr(expr
->right
);
833 nr
= get_argument_from_call_expr(right
->args
, param
);
834 size
= get_argument_from_call_expr(right
->args
, param
+ 1);
835 mult
= binop_expression(nr
, '*', size
);
836 if (get_implied_rl(mult
, &rl
))
837 store_alloc(expr
->left
, rl
);
839 store_alloc(expr
->left
, size_to_rl(UNKNOWN_SIZE
));
842 static void match_page(const char *fn
, struct expression
*expr
, void *_unused
)
849 store_alloc(expr
->left
, alloc_rl(page_size
, page_size
));
852 static void match_strndup(const char *fn
, struct expression
*expr
, void *unused
)
854 struct expression
*fn_expr
;
855 struct expression
*size_expr
;
858 fn_expr
= strip_expr(expr
->right
);
859 size_expr
= get_argument_from_call_expr(fn_expr
->args
, 1);
860 if (get_implied_max(size_expr
, &size
)) {
862 store_alloc(expr
->left
, size_to_rl(size
.value
));
864 store_alloc(expr
->left
, size_to_rl(UNKNOWN_SIZE
));
868 static void match_alloc_pages(const char *fn
, struct expression
*expr
, void *_order_arg
)
870 int order_arg
= PTR_INT(_order_arg
);
871 struct expression
*right
;
872 struct expression
*arg
;
875 right
= strip_expr(expr
->right
);
876 arg
= get_argument_from_call_expr(right
->args
, order_arg
);
877 if (!get_implied_value(arg
, &sval
))
879 if (sval
.value
< 0 || sval
.value
> 10)
882 sval
.type
= &int_ctype
;
883 sval
.value
= (1 << sval
.value
) * 4096;
885 store_alloc(expr
->left
, alloc_rl(sval
, sval
));
888 static int is_type_bytes(struct range_list
*rl
, struct expression
*call
, int nr
)
893 if (!rl_to_sval(rl
, &sval
))
896 type
= get_arg_type(call
->fn
, nr
);
899 if (type
->type
!= SYM_PTR
)
901 type
= get_real_base_type(type
);
902 if (sval
.value
!= type_bytes(type
))
907 static void match_call(struct expression
*expr
)
909 struct expression
*arg
;
911 struct range_list
*rl
;
915 FOR_EACH_PTR(expr
->args
, arg
) {
917 type
= get_type(arg
);
918 if (!type
|| (type
->type
!= SYM_PTR
&& type
->type
!= SYM_ARRAY
))
920 rl
= get_array_size_bytes_rl(arg
);
923 if (rl_min(rl
).value
== UNKNOWN_SIZE
&&
924 rl_max(rl
).value
== UNKNOWN_SIZE
)
928 if (is_type_bytes(rl
, expr
, i
))
930 sql_insert_caller_info(expr
, BUF_SIZE
, i
, "$", show_rl(rl
));
931 } END_FOR_EACH_PTR(arg
);
934 static void struct_member_callback(struct expression
*call
, int param
, char *printed_name
, struct sm_state
*sm
)
938 if (!estate_rl(sm
->state
) ||
939 (estate_get_single_value(sm
->state
, &sval
) &&
940 (sval
.value
== -1 || sval
.value
== 0)))
943 sql_insert_caller_info(call
, BUF_SIZE
, param
, printed_name
, sm
->state
->name
);
947 * This is slightly (very) weird because half of this stuff is handled in
948 * smatch_parse_call_math.c which is poorly named. But anyway, add some buf
952 static void print_returned_allocations(int return_id
, char *return_ranges
, struct expression
*expr
)
954 const char *param_math
;
955 struct range_list
*rl
;
959 rl
= get_array_size_bytes_rl(expr
);
960 param_math
= get_allocation_math(expr
);
961 if (!rl
&& !param_math
)
965 rl_to_sval(rl
, &sval
) &&
966 (sval
.value
== -1 || sval
.value
== 0))
970 snprintf(buf
, sizeof(buf
), "%s[%s]", show_rl(rl
), param_math
);
972 snprintf(buf
, sizeof(buf
), "%s", show_rl(rl
));
974 // FIXME: don't store if you can guess the size from the type
975 // FIXME: return if we allocate a parameter $0->bar
976 sql_insert_return_states(return_id
, return_ranges
, BUF_SIZE
, -1, "", buf
);
979 static void record_global_size(struct symbol
*sym
)
987 if (!(sym
->ctype
.modifiers
& MOD_TOPLEVEL
) ||
988 sym
->ctype
.modifiers
& MOD_STATIC
)
991 bytes
= get_array_size_bytes(symbol_expression(sym
));
995 snprintf(buf
, sizeof(buf
), "%d", bytes
);
996 sql_insert_data_info_var_sym(sym
->ident
->name
, sym
, BUF_SIZE
, buf
);
999 void register_buf_size(int id
)
1003 set_dynamic_states(my_size_id
);
1005 add_unmatched_state_hook(my_size_id
, &unmatched_size_state
);
1006 add_merge_hook(my_size_id
, &merge_estates
);
1008 select_caller_info_hook(set_param_buf_size
, BUF_SIZE
);
1009 select_return_states_hook(BUF_SIZE
, &db_returns_buf_size
);
1010 add_split_return_callback(print_returned_allocations
);
1012 allocation_funcs
= create_function_hashtable(100);
1013 add_allocation_function("malloc", &match_alloc
, 0);
1014 add_allocation_function("calloc", &match_calloc
, 0);
1015 add_allocation_function("memdup", &match_alloc
, 1);
1016 add_allocation_function("realloc", &match_alloc
, 1);
1017 if (option_project
== PROJ_KERNEL
) {
1018 add_allocation_function("kmalloc", &match_alloc
, 0);
1019 add_allocation_function("kmalloc_node", &match_alloc
, 0);
1020 add_allocation_function("kzalloc", &match_alloc
, 0);
1021 add_allocation_function("kzalloc_node", &match_alloc
, 0);
1022 add_allocation_function("vmalloc", &match_alloc
, 0);
1023 add_allocation_function("vzalloc", &match_alloc
, 0);
1024 add_allocation_function("__vmalloc", &match_alloc
, 0);
1025 add_allocation_function("kvmalloc", &match_alloc
, 0);
1026 add_allocation_function("kcalloc", &match_calloc
, 0);
1027 add_allocation_function("kvcalloc", &match_calloc
, 0);
1028 add_allocation_function("kmalloc_array", &match_calloc
, 0);
1029 add_allocation_function("devm_kmalloc_array", &match_calloc
, 1);
1030 add_allocation_function("sock_kmalloc", &match_alloc
, 1);
1031 add_allocation_function("kmemdup", &match_alloc
, 1);
1032 add_allocation_function("memdup_user", &match_alloc
, 1);
1033 add_allocation_function("dma_alloc_attrs", &match_alloc
, 1);
1034 add_allocation_function("devm_kmalloc", &match_alloc
, 1);
1035 add_allocation_function("devm_kzalloc", &match_alloc
, 1);
1036 add_allocation_function("krealloc", &match_alloc
, 1);
1037 add_allocation_function("__alloc_bootmem", &match_alloc
, 0);
1038 add_allocation_function("alloc_bootmem", &match_alloc
, 0);
1039 add_allocation_function("kmap", &match_page
, 0);
1040 add_allocation_function("kmap_atomic", &match_page
, 0);
1041 add_allocation_function("get_zeroed_page", &match_page
, 0);
1042 add_allocation_function("alloc_page", &match_page
, 0);
1043 add_allocation_function("alloc_pages", &match_alloc_pages
, 1);
1044 add_allocation_function("alloc_pages_current", &match_alloc_pages
, 1);
1045 add_allocation_function("__get_free_pages", &match_alloc_pages
, 1);
1046 add_allocation_function("dma_alloc_contiguous", &match_alloc
, 1);
1047 add_allocation_function("dma_alloc_coherent", &match_alloc
, 1);
1050 add_allocation_function("strndup", match_strndup
, 0);
1051 if (option_project
== PROJ_KERNEL
)
1052 add_allocation_function("kstrndup", match_strndup
, 0);
1054 add_modification_hook(my_size_id
, &set_size_undefined
);
1056 add_merge_hook(my_size_id
, &merge_size_func
);
1059 add_hook(record_global_size
, BASE_HOOK
);
1061 add_hook(&match_clear_cache
, AFTER_FUNC_HOOK
);
1064 void register_buf_size_late(int id
)
1066 /* has to happen after match_alloc() */
1067 add_hook(&match_array_assignment
, ASSIGNMENT_HOOK
);
1069 add_hook(&match_call
, FUNCTION_CALL_HOOK
);
1070 add_member_info_callback(my_size_id
, struct_member_callback
);