2 * Copyright (C) 2006 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
28 struct hook_container
{
33 ALLOCATOR(hook_container
, "hook functions");
34 DECLARE_PTR_LIST(hook_func_list
, struct hook_container
);
36 typedef void (sym_list_func
)(struct symbol_list
*sym_list
);
37 typedef void (array_init_hook
)(struct expression
*array
, int nr
);
39 static struct hook_func_list
*merge_funcs
;
40 static struct hook_func_list
*unmatched_state_funcs
;
41 static struct hook_func_list
*array_init_hooks
;
42 static struct hook_func_list
*hook_array
[NUM_HOOKS
] = {};
43 static const enum data_type data_types
[NUM_HOOKS
] = {
44 [EXPR_HOOK
] = EXPR_PTR
,
45 [EXPR_HOOK_AFTER
] = EXPR_PTR
,
46 [STMT_HOOK
] = STMT_PTR
,
47 [STMT_HOOK_AFTER
] = STMT_PTR
,
48 [SYM_HOOK
] = EXPR_PTR
,
49 [STRING_HOOK
] = EXPR_PTR
,
50 [DECLARATION_HOOK
] = SYMBOL_PTR
,
51 [DECLARATION_HOOK_AFTER
] = SYMBOL_PTR
,
52 [ASSIGNMENT_HOOK
] = EXPR_PTR
,
53 [ASSIGNMENT_HOOK_AFTER
] = EXPR_PTR
,
54 [RAW_ASSIGNMENT_HOOK
] = EXPR_PTR
,
55 [GLOBAL_ASSIGNMENT_HOOK
] = EXPR_PTR
,
56 [CALL_ASSIGNMENT_HOOK
] = EXPR_PTR
,
57 [MACRO_ASSIGNMENT_HOOK
] = EXPR_PTR
,
58 [BINOP_HOOK
] = EXPR_PTR
,
60 [LOGIC_HOOK
] = EXPR_PTR
,
61 [PRELOOP_HOOK
] = STMT_PTR
,
62 [POSTLOOP_HOOK
] = STMT_PTR
,
63 [AFTER_LOOP_NO_BREAKS
] = STMT_PTR
,
64 [CONDITION_HOOK
] = EXPR_PTR
,
65 [SELECT_HOOK
] = EXPR_PTR
,
66 [WHOLE_CONDITION_HOOK
] = EXPR_PTR
,
67 [FUNCTION_CALL_HOOK_BEFORE
] = EXPR_PTR
,
68 [FUNCTION_CALL_HOOK
] = EXPR_PTR
,
69 [CALL_HOOK_AFTER_INLINE
] = EXPR_PTR
,
70 [FUNCTION_CALL_HOOK_AFTER_DB
] = EXPR_PTR
,
71 [DEREF_HOOK
] = EXPR_PTR
,
72 [CASE_HOOK
] = NO_DATA
,
73 [ASM_HOOK
] = STMT_PTR
,
74 [CAST_HOOK
] = EXPR_PTR
,
75 [SIZEOF_HOOK
] = EXPR_PTR
,
76 [BASE_HOOK
] = SYMBOL_PTR
,
77 [FUNC_DEF_HOOK
] = SYMBOL_PTR
,
78 [AFTER_DEF_HOOK
] = SYMBOL_PTR
,
79 [END_FUNC_HOOK
] = SYMBOL_PTR
,
80 [AFTER_FUNC_HOOK
] = SYMBOL_PTR
,
81 [RETURN_HOOK
] = EXPR_PTR
,
82 [INLINE_FN_START
] = EXPR_PTR
,
83 [INLINE_FN_END
] = EXPR_PTR
,
84 [END_FILE_HOOK
] = SYM_LIST_PTR
,
87 void (**pre_merge_hooks
)(struct sm_state
*cur
, struct sm_state
*other
);
89 struct scope_container
{
93 ALLOCATOR(scope_container
, "scope hook functions");
94 DECLARE_PTR_LIST(scope_hook_list
, struct scope_container
);
95 DECLARE_PTR_LIST(scope_hook_stack
, struct scope_hook_list
);
96 static struct scope_hook_stack
*scope_hooks
;
98 void add_hook(void *func
, enum hook_type type
)
100 struct hook_container
*container
= __alloc_hook_container(0);
102 container
->hook_type
= type
;
103 container
->fn
= func
;
105 add_ptr_list(&hook_array
[type
], container
);
108 void add_merge_hook(int client_id
, merge_func_t
*func
)
110 struct hook_container
*container
= __alloc_hook_container(0);
111 container
->owner
= client_id
;
112 container
->fn
= func
;
113 add_ptr_list(&merge_funcs
, container
);
116 void add_unmatched_state_hook(int client_id
, unmatched_func_t
*func
)
118 struct hook_container
*container
= __alloc_hook_container(0);
119 container
->owner
= client_id
;
120 container
->fn
= func
;
121 add_ptr_list(&unmatched_state_funcs
, container
);
124 void add_pre_merge_hook(int client_id
, void (*hook
)(struct sm_state
*cur
, struct sm_state
*other
))
126 pre_merge_hooks
[client_id
] = hook
;
129 static void pass_expr_to_client(void *fn
, void *data
)
131 ((expr_func
*)fn
)((struct expression
*)data
);
134 static void pass_stmt_to_client(void *fn
, void *data
)
136 ((stmt_func
*)fn
)((struct statement
*)data
);
139 static void pass_sym_to_client(void *fn
, void *data
)
141 ((sym_func
*)fn
)((struct symbol
*)data
);
144 static void pass_sym_list_to_client(void *fn
, void *data
)
146 ((sym_list_func
*)fn
)((struct symbol_list
*)data
);
149 void __pass_to_client(void *data
, enum hook_type type
)
151 struct hook_container
*container
;
153 FOR_EACH_PTR(hook_array
[type
], container
) {
154 switch (data_types
[type
]) {
156 pass_expr_to_client(container
->fn
, data
);
159 pass_stmt_to_client(container
->fn
, data
);
162 pass_sym_to_client(container
->fn
, data
);
165 pass_sym_list_to_client(container
->fn
, data
);
168 sm_warning("internal error. Unhandled hook type: %d", type
);
170 } END_FOR_EACH_PTR(container
);
173 void __pass_case_to_client(struct expression
*switch_expr
,
174 struct range_list
*rl
)
176 typedef void (case_func
)(struct expression
*switch_expr
,
177 struct range_list
*rl
);
178 struct hook_container
*container
;
180 FOR_EACH_PTR(hook_array
[CASE_HOOK
], container
) {
181 ((case_func
*)container
->fn
)(switch_expr
, rl
);
182 } END_FOR_EACH_PTR(container
);
185 int __has_merge_function(int client_id
)
187 struct hook_container
*tmp
;
189 FOR_EACH_PTR(merge_funcs
, tmp
) {
190 if (tmp
->owner
== client_id
)
192 } END_FOR_EACH_PTR(tmp
);
196 struct smatch_state
*__client_merge_function(int owner
,
197 struct smatch_state
*s1
,
198 struct smatch_state
*s2
)
200 struct smatch_state
*tmp_state
;
201 struct hook_container
*tmp
;
203 /* Pass NULL states first and the rest alphabetically by name */
204 if (!s2
|| (s1
&& strcmp(s2
->name
, s1
->name
) < 0)) {
210 FOR_EACH_PTR(merge_funcs
, tmp
) {
211 if (tmp
->owner
== owner
)
212 return ((merge_func_t
*)tmp
->fn
)(s1
, s2
);
213 } END_FOR_EACH_PTR(tmp
);
217 struct smatch_state
*__client_unmatched_state_function(struct sm_state
*sm
)
219 struct hook_container
*tmp
;
221 FOR_EACH_PTR(unmatched_state_funcs
, tmp
) {
222 if (tmp
->owner
== sm
->owner
)
223 return ((unmatched_func_t
*)tmp
->fn
)(sm
);
224 } END_FOR_EACH_PTR(tmp
);
228 void call_pre_merge_hook(struct sm_state
*cur
, struct sm_state
*other
)
230 if (cur
->owner
>= num_checks
)
233 if (pre_merge_hooks
[cur
->owner
])
234 pre_merge_hooks
[cur
->owner
](cur
, other
);
237 static struct scope_hook_list
*pop_scope_hook_list(struct scope_hook_stack
**stack
)
239 struct scope_hook_list
*hook_list
;
241 hook_list
= last_ptr_list((struct ptr_list
*)*stack
);
242 delete_ptr_list_last((struct ptr_list
**)stack
);
246 static void push_scope_hook_list(struct scope_hook_stack
**stack
, struct scope_hook_list
*l
)
248 add_ptr_list(stack
, l
);
251 void add_scope_hook(scope_hook
*fn
, void *data
)
253 struct scope_hook_list
*hook_list
;
254 struct scope_container
*new;
258 hook_list
= pop_scope_hook_list(&scope_hooks
);
259 new = __alloc_scope_container(0);
262 add_ptr_list(&hook_list
, new);
263 push_scope_hook_list(&scope_hooks
, hook_list
);
266 void __push_scope_hooks(void)
268 push_scope_hook_list(&scope_hooks
, NULL
);
271 void __call_scope_hooks(void)
273 struct scope_hook_list
*hook_list
;
274 struct scope_container
*tmp
;
279 hook_list
= pop_scope_hook_list(&scope_hooks
);
280 FOR_EACH_PTR(hook_list
, tmp
) {
281 ((scope_hook
*)tmp
->fn
)(tmp
->data
);
282 __free_scope_container(tmp
);
283 } END_FOR_EACH_PTR(tmp
);
286 void add_array_initialized_hook(void (*hook
)(struct expression
*array
, int nr
))
288 struct hook_container
*container
= __alloc_hook_container(0);
290 container
->fn
= hook
;
292 add_ptr_list(&array_init_hooks
, container
);
295 void __call_array_initialized_hooks(struct expression
*array
, int nr
)
297 struct hook_container
*tmp
;
299 FOR_EACH_PTR(array_init_hooks
, tmp
) {
300 ((array_init_hook
*)tmp
->fn
)(array
, nr
);
301 } END_FOR_EACH_PTR(tmp
);
304 void allocate_hook_memory(void)
306 pre_merge_hooks
= malloc(num_checks
* sizeof(*pre_merge_hooks
));
307 memset(pre_merge_hooks
, 0, num_checks
* sizeof(*pre_merge_hooks
));
310 void call_void_fns(struct void_fn_list
*list
)
314 FOR_EACH_PTR(list
, fn
) {
316 } END_FOR_EACH_PTR(fn
);
319 void call_expr_fns(struct expr_fn_list
*list
, struct expression
*expr
)
323 FOR_EACH_PTR(list
, fn
) {
325 } END_FOR_EACH_PTR(fn
);
328 void call_stmt_fns(struct stmt_fn_list
*list
, struct statement
*stmt
)
332 FOR_EACH_PTR(list
, fn
) {
334 } END_FOR_EACH_PTR(fn
);
337 void call_sym_fns(struct sym_fn_list
*list
, struct symbol
*sym
)
341 FOR_EACH_PTR(list
, fn
) {
343 } END_FOR_EACH_PTR(fn
);
346 void call_name_sym_fns(struct name_sym_fn_list
*list
, struct expression
*expr
, const char *name
, struct symbol
*sym
)
350 FOR_EACH_PTR(list
, fn
) {
351 (fn
)(expr
, name
, sym
);
352 } END_FOR_EACH_PTR(fn
);
355 void call_string_hooks(struct string_hook_list
*list
, struct expression
*expr
, const char *str
)
359 FOR_EACH_PTR(list
, fn
) {
361 } END_FOR_EACH_PTR(fn
);