11f5207b7SJohn Levon /*
21f5207b7SJohn Levon  * Copyright (C) 2006,2008 Dan Carpenter.
31f5207b7SJohn Levon  *
41f5207b7SJohn Levon  * This program is free software; you can redistribute it and/or
51f5207b7SJohn Levon  * modify it under the terms of the GNU General Public License
61f5207b7SJohn Levon  * as published by the Free Software Foundation; either version 2
71f5207b7SJohn Levon  * of the License, or (at your option) any later version.
81f5207b7SJohn Levon  *
91f5207b7SJohn Levon  * This program is distributed in the hope that it will be useful,
101f5207b7SJohn Levon  * but WITHOUT ANY WARRANTY; without even the implied warranty of
111f5207b7SJohn Levon  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
121f5207b7SJohn Levon  * GNU General Public License for more details.
131f5207b7SJohn Levon  *
141f5207b7SJohn Levon  * You should have received a copy of the GNU General Public License
151f5207b7SJohn Levon  * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
161f5207b7SJohn Levon  */
171f5207b7SJohn Levon 
181f5207b7SJohn Levon #define _GNU_SOURCE 1
191f5207b7SJohn Levon #include <unistd.h>
201f5207b7SJohn Levon #include <stdio.h>
211f5207b7SJohn Levon #include "token.h"
221f5207b7SJohn Levon #include "scope.h"
231f5207b7SJohn Levon #include "smatch.h"
241f5207b7SJohn Levon #include "smatch_expression_stacks.h"
251f5207b7SJohn Levon #include "smatch_extra.h"
261f5207b7SJohn Levon #include "smatch_slist.h"
271f5207b7SJohn Levon 
281f5207b7SJohn Levon int __in_fake_assign;
291f5207b7SJohn Levon int __in_fake_struct_assign;
301f5207b7SJohn Levon int in_fake_env;
311f5207b7SJohn Levon int final_pass;
321f5207b7SJohn Levon int __inline_call;
331f5207b7SJohn Levon struct expression  *__inline_fn;
341f5207b7SJohn Levon 
351f5207b7SJohn Levon static int __smatch_lineno = 0;
361f5207b7SJohn Levon 
371f5207b7SJohn Levon static char *base_file;
381f5207b7SJohn Levon static const char *filename;
391f5207b7SJohn Levon static char *pathname;
401f5207b7SJohn Levon static char *full_filename;
411f5207b7SJohn Levon static char *full_base_file;
421f5207b7SJohn Levon static char *cur_func;
431f5207b7SJohn Levon static unsigned int loop_count;
441f5207b7SJohn Levon static int last_goto_statement_handled;
451f5207b7SJohn Levon int __expr_stmt_count;
461f5207b7SJohn Levon int __in_function_def;
47c85f09ccSJohn Levon int __in_unmatched_hook;
481f5207b7SJohn Levon static struct expression_list *switch_expr_stack = NULL;
491f5207b7SJohn Levon static struct expression_list *post_op_stack = NULL;
501f5207b7SJohn Levon 
511f5207b7SJohn Levon static struct ptr_list *backup;
521f5207b7SJohn Levon 
531f5207b7SJohn Levon struct expression_list *big_expression_stack;
541f5207b7SJohn Levon struct statement_list *big_statement_stack;
551f5207b7SJohn Levon struct statement *__prev_stmt;
561f5207b7SJohn Levon struct statement *__cur_stmt;
571f5207b7SJohn Levon struct statement *__next_stmt;
581f5207b7SJohn Levon int __in_pre_condition = 0;
591f5207b7SJohn Levon int __bail_on_rest_of_function = 0;
601f5207b7SJohn Levon static struct timeval fn_start_time;
611f5207b7SJohn Levon static struct timeval outer_fn_start_time;
get_function(void)621f5207b7SJohn Levon char *get_function(void) { return cur_func; }
get_lineno(void)631f5207b7SJohn Levon int get_lineno(void) { return __smatch_lineno; }
inside_loop(void)641f5207b7SJohn Levon int inside_loop(void) { return !!loop_count; }
definitely_inside_loop(void)651f5207b7SJohn Levon int definitely_inside_loop(void) { return !!(loop_count & ~0x08000000); }
get_switch_expr(void)661f5207b7SJohn Levon struct expression *get_switch_expr(void) { return top_expression(switch_expr_stack); }
in_expression_statement(void)671f5207b7SJohn Levon int in_expression_statement(void) { return !!__expr_stmt_count; }
681f5207b7SJohn Levon 
691f5207b7SJohn Levon static void split_symlist(struct symbol_list *sym_list);
701f5207b7SJohn Levon static void split_declaration(struct symbol_list *sym_list);
711f5207b7SJohn Levon static void split_expr_list(struct expression_list *expr_list, struct expression *parent);
721f5207b7SJohn Levon static void add_inline_function(struct symbol *sym);
731f5207b7SJohn Levon static void parse_inline(struct expression *expr);
741f5207b7SJohn Levon 
751f5207b7SJohn Levon int option_assume_loops = 0;
761f5207b7SJohn Levon int option_two_passes = 0;
771f5207b7SJohn Levon struct symbol *cur_func_sym = NULL;
781f5207b7SJohn Levon struct stree *global_states;
791f5207b7SJohn Levon 
80efe51d0cSJohn Levon const unsigned long valid_ptr_min = 4096;
81efe51d0cSJohn Levon unsigned long valid_ptr_max = ULONG_MAX & ~(MTAG_OFFSET_MASK);
82efe51d0cSJohn Levon const sval_t valid_ptr_min_sval = {
831f5207b7SJohn Levon 	.type = &ptr_ctype,
841f5207b7SJohn Levon 	{.value = 4096},
851f5207b7SJohn Levon };
861f5207b7SJohn Levon sval_t valid_ptr_max_sval = {
871f5207b7SJohn Levon 	.type = &ptr_ctype,
88efe51d0cSJohn Levon 	{.value = ULONG_MAX & ~(MTAG_OFFSET_MASK)},
891f5207b7SJohn Levon };
901f5207b7SJohn Levon struct range_list *valid_ptr_rl;
911f5207b7SJohn Levon 
alloc_valid_ptr_rl(void)92efe51d0cSJohn Levon void alloc_valid_ptr_rl(void)
931f5207b7SJohn Levon {
94efe51d0cSJohn Levon 	valid_ptr_max = sval_type_max(&ulong_ctype).value & ~(MTAG_OFFSET_MASK);
951f5207b7SJohn Levon 	valid_ptr_max_sval.value = valid_ptr_max;
961f5207b7SJohn Levon 
971f5207b7SJohn Levon 	valid_ptr_rl = alloc_rl(valid_ptr_min_sval, valid_ptr_max_sval);
981f5207b7SJohn Levon 	valid_ptr_rl = cast_rl(&ptr_ctype, valid_ptr_rl);
991f5207b7SJohn Levon 	valid_ptr_rl = clone_rl_permanent(valid_ptr_rl);
1001f5207b7SJohn Levon }
1011f5207b7SJohn Levon 
outside_of_function(void)1021f5207b7SJohn Levon int outside_of_function(void)
1031f5207b7SJohn Levon {
1041f5207b7SJohn Levon 	return cur_func_sym == NULL;
1051f5207b7SJohn Levon }
1061f5207b7SJohn Levon 
get_filename(void)1071f5207b7SJohn Levon const char *get_filename(void)
1081f5207b7SJohn Levon {
1091f5207b7SJohn Levon 	if (option_info && option_full_path)
1101f5207b7SJohn Levon 		return full_base_file;
1111f5207b7SJohn Levon 	if (option_info)
1121f5207b7SJohn Levon 		return base_file;
1131f5207b7SJohn Levon 	if (option_full_path)
1141f5207b7SJohn Levon 		return full_filename;
1151f5207b7SJohn Levon 	return filename;
1161f5207b7SJohn Levon }
1171f5207b7SJohn Levon 
get_base_file(void)1181f5207b7SJohn Levon const char *get_base_file(void)
1191f5207b7SJohn Levon {
1201f5207b7SJohn Levon 	if (option_full_path)
1211f5207b7SJohn Levon 		return full_base_file;
1221f5207b7SJohn Levon 	return base_file;
1231f5207b7SJohn Levon }
1241f5207b7SJohn Levon 
set_position(struct position pos)1251f5207b7SJohn Levon static void set_position(struct position pos)
1261f5207b7SJohn Levon {
1271f5207b7SJohn Levon 	int len;
1281f5207b7SJohn Levon 	static int prev_stream = -1;
1291f5207b7SJohn Levon 
1301f5207b7SJohn Levon 	if (in_fake_env)
1311f5207b7SJohn Levon 		return;
1321f5207b7SJohn Levon 
1331f5207b7SJohn Levon 	if (pos.stream == 0 && pos.line == 0)
1341f5207b7SJohn Levon 		return;
1351f5207b7SJohn Levon 
1361f5207b7SJohn Levon 	__smatch_lineno = pos.line;
1371f5207b7SJohn Levon 
1381f5207b7SJohn Levon 	if (pos.stream == prev_stream)
1391f5207b7SJohn Levon 		return;
1401f5207b7SJohn Levon 
1411f5207b7SJohn Levon 	filename = stream_name(pos.stream);
1421f5207b7SJohn Levon 
1431f5207b7SJohn Levon 	free(full_filename);
1441f5207b7SJohn Levon 	pathname = getcwd(NULL, 0);
1451f5207b7SJohn Levon 	if (pathname) {
1461f5207b7SJohn Levon 		len = strlen(pathname) + 1 + strlen(filename) + 1;
1471f5207b7SJohn Levon 		full_filename = malloc(len);
1481f5207b7SJohn Levon 		snprintf(full_filename, len, "%s/%s", pathname, filename);
1491f5207b7SJohn Levon 	} else {
1501f5207b7SJohn Levon 		full_filename = alloc_string(filename);
1511f5207b7SJohn Levon 	}
1521f5207b7SJohn Levon 	free(pathname);
1531f5207b7SJohn Levon }
1541f5207b7SJohn Levon 
is_assigned_call(struct expression * expr)1551f5207b7SJohn Levon int is_assigned_call(struct expression *expr)
1561f5207b7SJohn Levon {
1571f5207b7SJohn Levon 	struct expression *parent = expr_get_parent_expr(expr);
1581f5207b7SJohn Levon 
1591f5207b7SJohn Levon 	if (parent &&
1601f5207b7SJohn Levon 	    parent->type == EXPR_ASSIGNMENT &&
1611f5207b7SJohn Levon 	    parent->op == '=' &&
1621f5207b7SJohn Levon 	    strip_expr(parent->right) == expr)
1631f5207b7SJohn Levon 		return 1;
1641f5207b7SJohn Levon 
1651f5207b7SJohn Levon 	return 0;
1661f5207b7SJohn Levon }
1671f5207b7SJohn Levon 
is_inline_func(struct expression * expr)1681f5207b7SJohn Levon static int is_inline_func(struct expression *expr)
1691f5207b7SJohn Levon {
1701f5207b7SJohn Levon 	if (expr->type != EXPR_SYMBOL || !expr->symbol)
1711f5207b7SJohn Levon 		return 0;
1721f5207b7SJohn Levon 	if (expr->symbol->ctype.modifiers & MOD_INLINE)
1731f5207b7SJohn Levon 		return 1;
1741f5207b7SJohn Levon 	return 0;
1751f5207b7SJohn Levon }
1761f5207b7SJohn Levon 
is_noreturn_func(struct expression * expr)1771f5207b7SJohn Levon static int is_noreturn_func(struct expression *expr)
1781f5207b7SJohn Levon {
1791f5207b7SJohn Levon 	if (expr->type != EXPR_SYMBOL || !expr->symbol)
1801f5207b7SJohn Levon 		return 0;
1811f5207b7SJohn Levon 	if (expr->symbol->ctype.modifiers & MOD_NORETURN)
1821f5207b7SJohn Levon 		return 1;
1831f5207b7SJohn Levon 	return 0;
1841f5207b7SJohn Levon }
1851f5207b7SJohn Levon 
1861f5207b7SJohn Levon static int inline_budget = 20;
1871f5207b7SJohn Levon 
inlinable(struct expression * expr)1881f5207b7SJohn Levon int inlinable(struct expression *expr)
1891f5207b7SJohn Levon {
1901f5207b7SJohn Levon 	struct symbol *sym;
1911f5207b7SJohn Levon 	struct statement *last_stmt = NULL;
1921f5207b7SJohn Levon 
1931f5207b7SJohn Levon 	if (__inline_fn)  /* don't nest */
1941f5207b7SJohn Levon 		return 0;
1951f5207b7SJohn Levon 
1961f5207b7SJohn Levon 	if (expr->type != EXPR_SYMBOL || !expr->symbol)
1971f5207b7SJohn Levon 		return 0;
1981f5207b7SJohn Levon 	if (is_no_inline_function(expr->symbol->ident->name))
1991f5207b7SJohn Levon 		return 0;
2001f5207b7SJohn Levon 	sym = get_base_type(expr->symbol);
2011f5207b7SJohn Levon 	if (sym->stmt && sym->stmt->type == STMT_COMPOUND) {
2021f5207b7SJohn Levon 		if (ptr_list_size((struct ptr_list *)sym->stmt->stmts) > 10)
2031f5207b7SJohn Levon 			return 0;
2041f5207b7SJohn Levon 		if (sym->stmt->type != STMT_COMPOUND)
2051f5207b7SJohn Levon 			return 0;
2061f5207b7SJohn Levon 		last_stmt = last_ptr_list((struct ptr_list *)sym->stmt->stmts);
2071f5207b7SJohn Levon 	}
2081f5207b7SJohn Levon 	if (sym->inline_stmt && sym->inline_stmt->type == STMT_COMPOUND) {
2091f5207b7SJohn Levon 		if (ptr_list_size((struct ptr_list *)sym->inline_stmt->stmts) > 10)
2101f5207b7SJohn Levon 			return 0;
2111f5207b7SJohn Levon 		if (sym->inline_stmt->type != STMT_COMPOUND)
2121f5207b7SJohn Levon 			return 0;
2131f5207b7SJohn Levon 		last_stmt = last_ptr_list((struct ptr_list *)sym->inline_stmt->stmts);
2141f5207b7SJohn Levon 	}
2151f5207b7SJohn Levon 
2161f5207b7SJohn Levon 	if (!last_stmt)
2171f5207b7SJohn Levon 		return 0;
2181f5207b7SJohn Levon 
2191f5207b7SJohn Levon 	/* the magic numbers in this function are pulled out of my bum. */
2201f5207b7SJohn Levon 	if (last_stmt->pos.line > sym->pos.line + inline_budget)
2211f5207b7SJohn Levon 		return 0;
2221f5207b7SJohn Levon 
2231f5207b7SJohn Levon 	return 1;
2241f5207b7SJohn Levon }
2251f5207b7SJohn Levon 
__process_post_op_stack(void)2261f5207b7SJohn Levon void __process_post_op_stack(void)
2271f5207b7SJohn Levon {
2281f5207b7SJohn Levon 	struct expression *expr;
2291f5207b7SJohn Levon 
2301f5207b7SJohn Levon 	FOR_EACH_PTR(post_op_stack, expr) {
2311f5207b7SJohn Levon 		__pass_to_client(expr, OP_HOOK);
2321f5207b7SJohn Levon 	} END_FOR_EACH_PTR(expr);
2331f5207b7SJohn Levon 
2341f5207b7SJohn Levon 	__free_ptr_list((struct ptr_list **)&post_op_stack);
2351f5207b7SJohn Levon }
2361f5207b7SJohn Levon 
handle_comma_assigns(struct expression * expr)2371f5207b7SJohn Levon static int handle_comma_assigns(struct expression *expr)
2381f5207b7SJohn Levon {
2391f5207b7SJohn Levon 	struct expression *right;
2401f5207b7SJohn Levon 	struct expression *assign;
2411f5207b7SJohn Levon 
2421f5207b7SJohn Levon 	right = strip_expr(expr->right);
2431f5207b7SJohn Levon 	if (right->type != EXPR_COMMA)
2441f5207b7SJohn Levon 		return 0;
2451f5207b7SJohn Levon 
2461f5207b7SJohn Levon 	__split_expr(right->left);
2471f5207b7SJohn Levon 	__process_post_op_stack();
2481f5207b7SJohn Levon 
2491f5207b7SJohn Levon 	assign = assign_expression(expr->left, '=', right->right);
2501f5207b7SJohn Levon 	__split_expr(assign);
2511f5207b7SJohn Levon 
2521f5207b7SJohn Levon 	return 1;
2531f5207b7SJohn Levon }
2541f5207b7SJohn Levon 
2551f5207b7SJohn Levon /* This is to handle *p++ = foo; assignments */
handle_postop_assigns(struct expression * expr)2561f5207b7SJohn Levon static int handle_postop_assigns(struct expression *expr)
2571f5207b7SJohn Levon {
2581f5207b7SJohn Levon 	struct expression *left, *fake_left;
2591f5207b7SJohn Levon 	struct expression *assign;
2601f5207b7SJohn Levon 
2611f5207b7SJohn Levon 	left = strip_expr(expr->left);
2621f5207b7SJohn Levon 	if (left->type != EXPR_PREOP || left->op != '*')
2631f5207b7SJohn Levon 		return 0;
2641f5207b7SJohn Levon 	left = strip_expr(left->unop);
2651f5207b7SJohn Levon 	if (left->type != EXPR_POSTOP)
2661f5207b7SJohn Levon 		return 0;
2671f5207b7SJohn Levon 
2681f5207b7SJohn Levon 	fake_left = deref_expression(strip_expr(left->unop));
2691f5207b7SJohn Levon 	assign = assign_expression(fake_left, '=', expr->right);
2701f5207b7SJohn Levon 
2711f5207b7SJohn Levon 	__split_expr(assign);
2721f5207b7SJohn Levon 	__split_expr(expr->left);
2731f5207b7SJohn Levon 
2741f5207b7SJohn Levon 	return 1;
2751f5207b7SJohn Levon }
2761f5207b7SJohn Levon 
prev_expression_is_getting_address(struct expression * expr)2771f5207b7SJohn Levon static int prev_expression_is_getting_address(struct expression *expr)
2781f5207b7SJohn Levon {
2791f5207b7SJohn Levon 	struct expression *parent;
2801f5207b7SJohn Levon 
2811f5207b7SJohn Levon 	do {
2821f5207b7SJohn Levon 		parent = expr_get_parent_expr(expr);
2831f5207b7SJohn Levon 
2841f5207b7SJohn Levon 		if (!parent)
2851f5207b7SJohn Levon 			return 0;
2861f5207b7SJohn Levon 		if (parent->type == EXPR_PREOP && parent->op == '&')
2871f5207b7SJohn Levon 			return 1;
2881f5207b7SJohn Levon 		if (parent->type == EXPR_PREOP && parent->op == '(')
2891f5207b7SJohn Levon 			goto next;
2901f5207b7SJohn Levon 		if (parent->type == EXPR_DEREF && parent->op == '.')
2911f5207b7SJohn Levon 			goto next;
2921f5207b7SJohn Levon 
2931f5207b7SJohn Levon 		return 0;
2941f5207b7SJohn Levon next:
2951f5207b7SJohn Levon 		expr = parent;
2961f5207b7SJohn Levon 	} while (1);
2971f5207b7SJohn Levon }
2981f5207b7SJohn Levon 
handle_builtin_overflow_func(struct expression * expr)2991f5207b7SJohn Levon static void handle_builtin_overflow_func(struct expression *expr)
3001f5207b7SJohn Levon {
3011f5207b7SJohn Levon 	struct expression *a, *b, *res, *assign;
3021f5207b7SJohn Levon 	int op;
3031f5207b7SJohn Levon 
3041f5207b7SJohn Levon 	if (sym_name_is("__builtin_add_overflow", expr->fn))
3051f5207b7SJohn Levon 		op = '+';
3061f5207b7SJohn Levon 	else if (sym_name_is("__builtin_sub_overflow", expr->fn))
3071f5207b7SJohn Levon 		op = '-';
3081f5207b7SJohn Levon 	else if (sym_name_is("__builtin_mul_overflow", expr->fn))
3091f5207b7SJohn Levon 		op = '*';
3101f5207b7SJohn Levon 	else
3111f5207b7SJohn Levon 		return;
3121f5207b7SJohn Levon 
3131f5207b7SJohn Levon 	a = get_argument_from_call_expr(expr->args, 0);
3141f5207b7SJohn Levon 	b = get_argument_from_call_expr(expr->args, 1);
3151f5207b7SJohn Levon 	res = get_argument_from_call_expr(expr->args, 2);
3161f5207b7SJohn Levon 
3171f5207b7SJohn Levon 	assign = assign_expression(deref_expression(res), '=', binop_expression(a, op, b));
3181f5207b7SJohn Levon 	__split_expr(assign);
3191f5207b7SJohn Levon }
3201f5207b7SJohn Levon 
handle__builtin_choose_expr(struct expression * expr)3211f5207b7SJohn Levon static int handle__builtin_choose_expr(struct expression *expr)
3221f5207b7SJohn Levon {
3231f5207b7SJohn Levon 	struct expression *const_expr, *expr1, *expr2;
3241f5207b7SJohn Levon 	sval_t sval;
3251f5207b7SJohn Levon 
3261f5207b7SJohn Levon 	if (!sym_name_is("__builtin_choose_expr", expr->fn))
3271f5207b7SJohn Levon 		return 0;
3281f5207b7SJohn Levon 
3291f5207b7SJohn Levon 	const_expr = get_argument_from_call_expr(expr->args, 0);
3301f5207b7SJohn Levon 	expr1 = get_argument_from_call_expr(expr->args, 1);
3311f5207b7SJohn Levon 	expr2 = get_argument_from_call_expr(expr->args, 2);
3321f5207b7SJohn Levon 
3331f5207b7SJohn Levon 	if (!get_value(const_expr, &sval) || !expr1 || !expr2)
3341f5207b7SJohn Levon 		return 0;
3351f5207b7SJohn Levon 	if (sval.value)
3361f5207b7SJohn Levon 		__split_expr(expr1);
3371f5207b7SJohn Levon 	else
3381f5207b7SJohn Levon 		__split_expr(expr2);
3391f5207b7SJohn Levon 	return 1;
3401f5207b7SJohn Levon }
3411f5207b7SJohn Levon 
handle__builtin_choose_expr_assigns(struct expression * expr)3421f5207b7SJohn Levon static int handle__builtin_choose_expr_assigns(struct expression *expr)
3431f5207b7SJohn Levon {
3441f5207b7SJohn Levon 	struct expression *const_expr, *right, *expr1, *expr2, *fake;
3451f5207b7SJohn Levon 	sval_t sval;
3461f5207b7SJohn Levon 
3471f5207b7SJohn Levon 	right = strip_expr(expr->right);
3481f5207b7SJohn Levon 	if (right->type != EXPR_CALL)
3491f5207b7SJohn Levon 		return 0;
3501f5207b7SJohn Levon 	if (!sym_name_is("__builtin_choose_expr", right->fn))
3511f5207b7SJohn Levon 		return 0;
3521f5207b7SJohn Levon 
3531f5207b7SJohn Levon 	const_expr = get_argument_from_call_expr(right->args, 0);
3541f5207b7SJohn Levon 	expr1 = get_argument_from_call_expr(right->args, 1);
3551f5207b7SJohn Levon 	expr2 = get_argument_from_call_expr(right->args, 2);
3561f5207b7SJohn Levon 
3571f5207b7SJohn Levon 	if (!get_value(const_expr, &sval) || !expr1 || !expr2)
3581f5207b7SJohn Levon 		return 0;
3591f5207b7SJohn Levon 
3601f5207b7SJohn Levon 	fake = assign_expression(expr->left, '=', sval.value ? expr1 : expr2);
3611f5207b7SJohn Levon 	__split_expr(fake);
3621f5207b7SJohn Levon 	return 1;
3631f5207b7SJohn Levon }
3641f5207b7SJohn Levon 
__split_expr(struct expression * expr)3651f5207b7SJohn Levon void __split_expr(struct expression *expr)
3661f5207b7SJohn Levon {
3671f5207b7SJohn Levon 	if (!expr)
3681f5207b7SJohn Levon 		return;
3691f5207b7SJohn Levon 
3701f5207b7SJohn Levon 	// sm_msg(" Debug expr_type %d %s", expr->type, show_special(expr->op));
3711f5207b7SJohn Levon 
3721f5207b7SJohn Levon 	if (__in_fake_assign && expr->type != EXPR_ASSIGNMENT)
3731f5207b7SJohn Levon 		return;
3741f5207b7SJohn Levon 	if (__in_fake_assign >= 4)  /* don't allow too much nesting */
3751f5207b7SJohn Levon 		return;
3761f5207b7SJohn Levon 
3771f5207b7SJohn Levon 	push_expression(&big_expression_stack, expr);
3781f5207b7SJohn Levon 	set_position(expr->pos);
3791f5207b7SJohn Levon 	__pass_to_client(expr, EXPR_HOOK);
3801f5207b7SJohn Levon 
3811f5207b7SJohn Levon 	switch (expr->type) {
3821f5207b7SJohn Levon 	case EXPR_PREOP:
3831f5207b7SJohn Levon 		expr_set_parent_expr(expr->unop, expr);
3841f5207b7SJohn Levon 
3851f5207b7SJohn Levon 		if (expr->op == '*' &&
3861f5207b7SJohn Levon 		    !prev_expression_is_getting_address(expr))
3871f5207b7SJohn Levon 			__pass_to_client(expr, DEREF_HOOK);
3881f5207b7SJohn Levon 		__split_expr(expr->unop);
3891f5207b7SJohn Levon 		__pass_to_client(expr, OP_HOOK);
3901f5207b7SJohn Levon 		break;
3911f5207b7SJohn Levon 	case EXPR_POSTOP:
3921f5207b7SJohn Levon 		expr_set_parent_expr(expr->unop, expr);
3931f5207b7SJohn Levon 
3941f5207b7SJohn Levon 		__split_expr(expr->unop);
3951f5207b7SJohn Levon 		push_expression(&post_op_stack, expr);
3961f5207b7SJohn Levon 		break;
3971f5207b7SJohn Levon 	case EXPR_STATEMENT:
3981f5207b7SJohn Levon 		__expr_stmt_count++;
3991f5207b7SJohn Levon 		if (expr->statement && !expr->statement) {
4001f5207b7SJohn Levon 			stmt_set_parent_stmt(expr->statement,
4011f5207b7SJohn Levon 					last_ptr_list((struct ptr_list *)big_statement_stack));
4021f5207b7SJohn Levon 		}
4031f5207b7SJohn Levon 		__split_stmt(expr->statement);
4041f5207b7SJohn Levon 		__expr_stmt_count--;
4051f5207b7SJohn Levon 		break;
4061f5207b7SJohn Levon 	case EXPR_LOGICAL:
4071f5207b7SJohn Levon 	case EXPR_COMPARE:
4081f5207b7SJohn Levon 		expr_set_parent_expr(expr->left, expr);
4091f5207b7SJohn Levon 		expr_set_parent_expr(expr->right, expr);
4101f5207b7SJohn Levon 
4111f5207b7SJohn Levon 		__pass_to_client(expr, LOGIC_HOOK);
4121f5207b7SJohn Levon 		__handle_logic(expr);
4131f5207b7SJohn Levon 		break;
4141f5207b7SJohn Levon 	case EXPR_BINOP:
4151f5207b7SJohn Levon 		expr_set_parent_expr(expr->left, expr);
4161f5207b7SJohn Levon 		expr_set_parent_expr(expr->right, expr);
4171f5207b7SJohn Levon 
4181f5207b7SJohn Levon 		__pass_to_client(expr, BINOP_HOOK);
4191f5207b7SJohn Levon 	case EXPR_COMMA:
4201f5207b7SJohn Levon 		expr_set_parent_expr(expr->left, expr);
4211f5207b7SJohn Levon 		expr_set_parent_expr(expr->right, expr);
4221f5207b7SJohn Levon 
4231f5207b7SJohn Levon 		__split_expr(expr->left);
4241f5207b7SJohn Levon 		__process_post_op_stack();
4251f5207b7SJohn Levon 		__split_expr(expr->right);
4261f5207b7SJohn Levon 		break;
4271f5207b7SJohn Levon 	case EXPR_ASSIGNMENT: {
4281f5207b7SJohn Levon 		struct expression *right;
4291f5207b7SJohn Levon 
4301f5207b7SJohn Levon 		expr_set_parent_expr(expr->left, expr);
4311f5207b7SJohn Levon 		expr_set_parent_expr(expr->right, expr);
4321f5207b7SJohn Levon 
4331f5207b7SJohn Levon 		right = strip_expr(expr->right);
4341f5207b7SJohn Levon 		if (!right)
4351f5207b7SJohn Levon 			break;
4361f5207b7SJohn Levon 
4371f5207b7SJohn Levon 		__pass_to_client(expr, RAW_ASSIGNMENT_HOOK);
4381f5207b7SJohn Levon 
4391f5207b7SJohn Levon 		/* foo = !bar() */
4401f5207b7SJohn Levon 		if (__handle_condition_assigns(expr))
441*6523a3aaSJohn Levon 			goto after_assign;
4421f5207b7SJohn Levon 		/* foo = (x < 5 ? foo : 5); */
4431f5207b7SJohn Levon 		if (__handle_select_assigns(expr))
444*6523a3aaSJohn Levon 			goto after_assign;
4451f5207b7SJohn Levon 		/* foo = ({frob(); frob(); frob(); 1;}) */
4461f5207b7SJohn Levon 		if (__handle_expr_statement_assigns(expr))
447*6523a3aaSJohn Levon 			break;  // FIXME: got after
4481f5207b7SJohn Levon 		/* foo = (3, 4); */
4491f5207b7SJohn Levon 		if (handle_comma_assigns(expr))
450*6523a3aaSJohn Levon 			goto after_assign;
4511f5207b7SJohn Levon 		if (handle__builtin_choose_expr_assigns(expr))
452*6523a3aaSJohn Levon 			goto after_assign;
453*6523a3aaSJohn Levon 		if (handle_postop_assigns(expr))
454*6523a3aaSJohn Levon 			break;  /* no need to goto after_assign */
4551f5207b7SJohn Levon 
4561f5207b7SJohn Levon 		__split_expr(expr->right);
4571f5207b7SJohn Levon 		if (outside_of_function())
4581f5207b7SJohn Levon 			__pass_to_client(expr, GLOBAL_ASSIGNMENT_HOOK);
4591f5207b7SJohn Levon 		else
4601f5207b7SJohn Levon 			__pass_to_client(expr, ASSIGNMENT_HOOK);
4611f5207b7SJohn Levon 
4621f5207b7SJohn Levon 		__fake_struct_member_assignments(expr);
4631f5207b7SJohn Levon 
464c85f09ccSJohn Levon 		/* Re-examine ->right for inlines.  See the commit message */
465c85f09ccSJohn Levon 		right = strip_expr(expr->right);
4661f5207b7SJohn Levon 		if (expr->op == '=' && right->type == EXPR_CALL)
4671f5207b7SJohn Levon 			__pass_to_client(expr, CALL_ASSIGNMENT_HOOK);
4681f5207b7SJohn Levon 
4691f5207b7SJohn Levon 		if (get_macro_name(right->pos) &&
4701f5207b7SJohn Levon 		    get_macro_name(expr->pos) != get_macro_name(right->pos))
4711f5207b7SJohn Levon 			__pass_to_client(expr, MACRO_ASSIGNMENT_HOOK);
4721f5207b7SJohn Levon 
473*6523a3aaSJohn Levon after_assign:
4741f5207b7SJohn Levon 		__pass_to_client(expr, ASSIGNMENT_HOOK_AFTER);
4751f5207b7SJohn Levon 		__split_expr(expr->left);
4761f5207b7SJohn Levon 		break;
4771f5207b7SJohn Levon 	}
4781f5207b7SJohn Levon 	case EXPR_DEREF:
4791f5207b7SJohn Levon 		expr_set_parent_expr(expr->deref, expr);
4801f5207b7SJohn Levon 
4811f5207b7SJohn Levon 		__pass_to_client(expr, DEREF_HOOK);
4821f5207b7SJohn Levon 		__split_expr(expr->deref);
4831f5207b7SJohn Levon 		break;
4841f5207b7SJohn Levon 	case EXPR_SLICE:
4851f5207b7SJohn Levon 		expr_set_parent_expr(expr->base, expr);
4861f5207b7SJohn Levon 
4871f5207b7SJohn Levon 		__split_expr(expr->base);
4881f5207b7SJohn Levon 		break;
4891f5207b7SJohn Levon 	case EXPR_CAST:
4901f5207b7SJohn Levon 	case EXPR_FORCE_CAST:
4911f5207b7SJohn Levon 		expr_set_parent_expr(expr->cast_expression, expr);
4921f5207b7SJohn Levon 
4931f5207b7SJohn Levon 		__pass_to_client(expr, CAST_HOOK);
4941f5207b7SJohn Levon 		__split_expr(expr->cast_expression);
4951f5207b7SJohn Levon 		break;
4961f5207b7SJohn Levon 	case EXPR_SIZEOF:
4971f5207b7SJohn Levon 		if (expr->cast_expression)
4981f5207b7SJohn Levon 			__pass_to_client(strip_parens(expr->cast_expression),
4991f5207b7SJohn Levon 					 SIZEOF_HOOK);
5001f5207b7SJohn Levon 		break;
5011f5207b7SJohn Levon 	case EXPR_OFFSETOF:
5021f5207b7SJohn Levon 	case EXPR_ALIGNOF:
5031f5207b7SJohn Levon 		break;
5041f5207b7SJohn Levon 	case EXPR_CONDITIONAL:
5051f5207b7SJohn Levon 	case EXPR_SELECT:
5061f5207b7SJohn Levon 		expr_set_parent_expr(expr->conditional, expr);
5071f5207b7SJohn Levon 		expr_set_parent_expr(expr->cond_true, expr);
5081f5207b7SJohn Levon 		expr_set_parent_expr(expr->cond_false, expr);
5091f5207b7SJohn Levon 
5101f5207b7SJohn Levon 		if (known_condition_true(expr->conditional)) {
5111f5207b7SJohn Levon 			__split_expr(expr->cond_true);
5121f5207b7SJohn Levon 			break;
5131f5207b7SJohn Levon 		}
5141f5207b7SJohn Levon 		if (known_condition_false(expr->conditional)) {
5151f5207b7SJohn Levon 			__split_expr(expr->cond_false);
5161f5207b7SJohn Levon 			break;
5171f5207b7SJohn Levon 		}
5181f5207b7SJohn Levon 		__pass_to_client(expr, SELECT_HOOK);
5191f5207b7SJohn Levon 		__split_whole_condition(expr->conditional);
5201f5207b7SJohn Levon 		__split_expr(expr->cond_true);
5211f5207b7SJohn Levon 		__push_true_states();
5221f5207b7SJohn Levon 		__use_false_states();
5231f5207b7SJohn Levon 		__split_expr(expr->cond_false);
5241f5207b7SJohn Levon 		__merge_true_states();
5251f5207b7SJohn Levon 		break;
5261f5207b7SJohn Levon 	case EXPR_CALL:
5271f5207b7SJohn Levon 		expr_set_parent_expr(expr->fn, expr);
5281f5207b7SJohn Levon 
5291f5207b7SJohn Levon 		if (sym_name_is("__builtin_constant_p", expr->fn))
5301f5207b7SJohn Levon 			break;
5311f5207b7SJohn Levon 		if (handle__builtin_choose_expr(expr))
5321f5207b7SJohn Levon 			break;
5331f5207b7SJohn Levon 		__split_expr(expr->fn);
534c85f09ccSJohn Levon 		split_expr_list(expr->args, expr);
5351f5207b7SJohn Levon 		if (is_inline_func(expr->fn))
5361f5207b7SJohn Levon 			add_inline_function(expr->fn->symbol);
5371f5207b7SJohn Levon 		if (inlinable(expr->fn))
5381f5207b7SJohn Levon 			__inline_call = 1;
5391f5207b7SJohn Levon 		__process_post_op_stack();
5401f5207b7SJohn Levon 		__pass_to_client(expr, FUNCTION_CALL_HOOK_BEFORE);
5411f5207b7SJohn Levon 		__pass_to_client(expr, FUNCTION_CALL_HOOK);
5421f5207b7SJohn Levon 		__inline_call = 0;
5431f5207b7SJohn Levon 		if (inlinable(expr->fn)) {
5441f5207b7SJohn Levon 			parse_inline(expr);
5451f5207b7SJohn Levon 		}
5461f5207b7SJohn Levon 		__pass_to_client(expr, CALL_HOOK_AFTER_INLINE);
5471f5207b7SJohn Levon 		if (is_noreturn_func(expr->fn))
5481f5207b7SJohn Levon 			nullify_path();
5491f5207b7SJohn Levon 		handle_builtin_overflow_func(expr);
5501f5207b7SJohn Levon 		break;
5511f5207b7SJohn Levon 	case EXPR_INITIALIZER:
5521f5207b7SJohn Levon 		split_expr_list(expr->expr_list, expr);
5531f5207b7SJohn Levon 		break;
5541f5207b7SJohn Levon 	case EXPR_IDENTIFIER:
5551f5207b7SJohn Levon 		expr_set_parent_expr(expr->ident_expression, expr);
5561f5207b7SJohn Levon 		__split_expr(expr->ident_expression);
5571f5207b7SJohn Levon 		break;
5581f5207b7SJohn Levon 	case EXPR_INDEX:
5591f5207b7SJohn Levon 		expr_set_parent_expr(expr->idx_expression, expr);
5601f5207b7SJohn Levon 		__split_expr(expr->idx_expression);
5611f5207b7SJohn Levon 		break;
5621f5207b7SJohn Levon 	case EXPR_POS:
5631f5207b7SJohn Levon 		expr_set_parent_expr(expr->init_expr, expr);
5641f5207b7SJohn Levon 		__split_expr(expr->init_expr);
5651f5207b7SJohn Levon 		break;
5661f5207b7SJohn Levon 	case EXPR_SYMBOL:
5671f5207b7SJohn Levon 		__pass_to_client(expr, SYM_HOOK);
5681f5207b7SJohn Levon 		break;
5691f5207b7SJohn Levon 	case EXPR_STRING:
5701f5207b7SJohn Levon 		__pass_to_client(expr, STRING_HOOK);
5711f5207b7SJohn Levon 		break;
5721f5207b7SJohn Levon 	default:
5731f5207b7SJohn Levon 		break;
5741f5207b7SJohn Levon 	};
575c85f09ccSJohn Levon 	__pass_to_client(expr, EXPR_HOOK_AFTER);
5761f5207b7SJohn Levon 	pop_expression(&big_expression_stack);
5771f5207b7SJohn Levon }
5781f5207b7SJohn Levon 
is_forever_loop(struct statement * stmt)5791f5207b7SJohn Levon static int is_forever_loop(struct statement *stmt)
5801f5207b7SJohn Levon {
5811f5207b7SJohn Levon 	struct expression *expr;
5821f5207b7SJohn Levon 	sval_t sval;
5831f5207b7SJohn Levon 
5841f5207b7SJohn Levon 	expr = strip_expr(stmt->iterator_pre_condition);
5851f5207b7SJohn Levon 	if (!expr)
5861f5207b7SJohn Levon 		expr = stmt->iterator_post_condition;
5871f5207b7SJohn Levon 	if (!expr) {
5881f5207b7SJohn Levon 		/* this is a for(;;) loop... */
5891f5207b7SJohn Levon 		return 1;
5901f5207b7SJohn Levon 	}
5911f5207b7SJohn Levon 
5921f5207b7SJohn Levon 	if (get_value(expr, &sval) && sval.value != 0)
5931f5207b7SJohn Levon 		return 1;
5941f5207b7SJohn Levon 
5951f5207b7SJohn Levon 	return 0;
5961f5207b7SJohn Levon }
5971f5207b7SJohn Levon 
5981f5207b7SJohn Levon static int loop_num;
get_loop_name(int num)5991f5207b7SJohn Levon static char *get_loop_name(int num)
6001f5207b7SJohn Levon {
6011f5207b7SJohn Levon 	char buf[256];
6021f5207b7SJohn Levon 
6031f5207b7SJohn Levon 	snprintf(buf, 255, "-loop%d", num);
6041f5207b7SJohn Levon 	buf[255] = '\0';
6051f5207b7SJohn Levon 	return alloc_sname(buf);
6061f5207b7SJohn Levon }
6071f5207b7SJohn Levon 
6081f5207b7SJohn Levon /*
6091f5207b7SJohn Levon  * Pre Loops are while and for loops.
6101f5207b7SJohn Levon  */
handle_pre_loop(struct statement * stmt)6111f5207b7SJohn Levon static void handle_pre_loop(struct statement *stmt)
6121f5207b7SJohn Levon {
6131f5207b7SJohn Levon 	int once_through; /* we go through the loop at least once */
6141f5207b7SJohn Levon 	struct sm_state *extra_sm = NULL;
6151f5207b7SJohn Levon 	int unchanged = 0;
6161f5207b7SJohn Levon 	char *loop_name;
6171f5207b7SJohn Levon 	struct stree *stree = NULL;
6181f5207b7SJohn Levon 	struct sm_state *sm = NULL;
6191f5207b7SJohn Levon 
6201f5207b7SJohn Levon 	loop_name = get_loop_name(loop_num);
6211f5207b7SJohn Levon 	loop_num++;
6221f5207b7SJohn Levon 
6231f5207b7SJohn Levon 	__split_stmt(stmt->iterator_pre_statement);
6241f5207b7SJohn Levon 	__prev_stmt = stmt->iterator_pre_statement;
6251f5207b7SJohn Levon 
6261f5207b7SJohn Levon 	once_through = implied_condition_true(stmt->iterator_pre_condition);
6271f5207b7SJohn Levon 
6281f5207b7SJohn Levon 	loop_count++;
6291f5207b7SJohn Levon 	__push_continues();
6301f5207b7SJohn Levon 	__push_breaks();
6311f5207b7SJohn Levon 
6321f5207b7SJohn Levon 	__merge_gotos(loop_name, NULL);
6331f5207b7SJohn Levon 
6341f5207b7SJohn Levon 	extra_sm = __extra_handle_canonical_loops(stmt, &stree);
6351f5207b7SJohn Levon 	__in_pre_condition++;
6361f5207b7SJohn Levon 	__pass_to_client(stmt, PRELOOP_HOOK);
6371f5207b7SJohn Levon 	__split_whole_condition(stmt->iterator_pre_condition);
6381f5207b7SJohn Levon 	__in_pre_condition--;
6391f5207b7SJohn Levon 	FOR_EACH_SM(stree, sm) {
6401f5207b7SJohn Levon 		set_state(sm->owner, sm->name, sm->sym, sm->state);
6411f5207b7SJohn Levon 	} END_FOR_EACH_SM(sm);
6421f5207b7SJohn Levon 	free_stree(&stree);
6431f5207b7SJohn Levon 	if (extra_sm)
6441f5207b7SJohn Levon 		extra_sm = get_sm_state(extra_sm->owner, extra_sm->name, extra_sm->sym);
6451f5207b7SJohn Levon 
6461f5207b7SJohn Levon 	if (option_assume_loops)
6471f5207b7SJohn Levon 		once_through = 1;
6481f5207b7SJohn Levon 
6491f5207b7SJohn Levon 	__split_stmt(stmt->iterator_statement);
6501f5207b7SJohn Levon 	if (is_forever_loop(stmt)) {
6511f5207b7SJohn Levon 		__merge_continues();
6521f5207b7SJohn Levon 		__save_gotos(loop_name, NULL);
6531f5207b7SJohn Levon 
6541f5207b7SJohn Levon 		__push_fake_cur_stree();
6551f5207b7SJohn Levon 		__split_stmt(stmt->iterator_post_statement);
6561f5207b7SJohn Levon 		stree = __pop_fake_cur_stree();
6571f5207b7SJohn Levon 
6581f5207b7SJohn Levon 		__discard_false_states();
6591f5207b7SJohn Levon 		__use_breaks();
6601f5207b7SJohn Levon 
6611f5207b7SJohn Levon 		if (!__path_is_null())
6621f5207b7SJohn Levon 			__merge_stree_into_cur(stree);
6631f5207b7SJohn Levon 		free_stree(&stree);
6641f5207b7SJohn Levon 	} else {
6651f5207b7SJohn Levon 		__merge_continues();
6661f5207b7SJohn Levon 		unchanged = __iterator_unchanged(extra_sm);
6671f5207b7SJohn Levon 		__split_stmt(stmt->iterator_post_statement);
6681f5207b7SJohn Levon 		__prev_stmt = stmt->iterator_post_statement;
6691f5207b7SJohn Levon 		__cur_stmt = stmt;
6701f5207b7SJohn Levon 
6711f5207b7SJohn Levon 		__save_gotos(loop_name, NULL);
6721f5207b7SJohn Levon 		__in_pre_condition++;
6731f5207b7SJohn Levon 		__split_whole_condition(stmt->iterator_pre_condition);
6741f5207b7SJohn Levon 		__in_pre_condition--;
6751f5207b7SJohn Levon 		nullify_path();
6761f5207b7SJohn Levon 		__merge_false_states();
6771f5207b7SJohn Levon 		if (once_through)
6781f5207b7SJohn Levon 			__discard_false_states();
6791f5207b7SJohn Levon 		else
6801f5207b7SJohn Levon 			__merge_false_states();
6811f5207b7SJohn Levon 
6821f5207b7SJohn Levon 		if (extra_sm && unchanged)
6831f5207b7SJohn Levon 			__extra_pre_loop_hook_after(extra_sm,
6841f5207b7SJohn Levon 						stmt->iterator_post_statement,
6851f5207b7SJohn Levon 						stmt->iterator_pre_condition);
6861f5207b7SJohn Levon 		__merge_breaks();
6871f5207b7SJohn Levon 	}
6881f5207b7SJohn Levon 	loop_count--;
6891f5207b7SJohn Levon }
6901f5207b7SJohn Levon 
6911f5207b7SJohn Levon /*
6921f5207b7SJohn Levon  * Post loops are do {} while();
6931f5207b7SJohn Levon  */
handle_post_loop(struct statement * stmt)6941f5207b7SJohn Levon static void handle_post_loop(struct statement *stmt)
6951f5207b7SJohn Levon {
6961f5207b7SJohn Levon 	char *loop_name;
6971f5207b7SJohn Levon 
6981f5207b7SJohn Levon 	loop_name = get_loop_name(loop_num);
6991f5207b7SJohn Levon 	loop_num++;
7001f5207b7SJohn Levon 	loop_count++;
7011f5207b7SJohn Levon 
7021f5207b7SJohn Levon 	__push_continues();
7031f5207b7SJohn Levon 	__push_breaks();
7041f5207b7SJohn Levon 	__merge_gotos(loop_name, NULL);
7051f5207b7SJohn Levon 	__split_stmt(stmt->iterator_statement);
7061f5207b7SJohn Levon 	__merge_continues();
707c85f09ccSJohn Levon 	if (!expr_is_zero(stmt->iterator_post_condition))
7081f5207b7SJohn Levon 		__save_gotos(loop_name, NULL);
7091f5207b7SJohn Levon 
7101f5207b7SJohn Levon 	if (is_forever_loop(stmt)) {
7111f5207b7SJohn Levon 		__use_breaks();
7121f5207b7SJohn Levon 	} else {
7131f5207b7SJohn Levon 		__split_whole_condition(stmt->iterator_post_condition);
7141f5207b7SJohn Levon 		__use_false_states();
7151f5207b7SJohn Levon 		__merge_breaks();
7161f5207b7SJohn Levon 	}
7171f5207b7SJohn Levon 	loop_count--;
7181f5207b7SJohn Levon }
7191f5207b7SJohn Levon 
empty_statement(struct statement * stmt)7201f5207b7SJohn Levon static int empty_statement(struct statement *stmt)
7211f5207b7SJohn Levon {
7221f5207b7SJohn Levon 	if (!stmt)
7231f5207b7SJohn Levon 		return 0;
7241f5207b7SJohn Levon 	if (stmt->type == STMT_EXPRESSION && !stmt->expression)
7251f5207b7SJohn Levon 		return 1;
7261f5207b7SJohn Levon 	return 0;
7271f5207b7SJohn Levon }
7281f5207b7SJohn Levon 
last_stmt_on_same_line(void)7291f5207b7SJohn Levon static int last_stmt_on_same_line(void)
7301f5207b7SJohn Levon {
7311f5207b7SJohn Levon 	struct statement *stmt;
7321f5207b7SJohn Levon 	int i = 0;
7331f5207b7SJohn Levon 
7341f5207b7SJohn Levon 	FOR_EACH_PTR_REVERSE(big_statement_stack, stmt) {
7351f5207b7SJohn Levon 		if (!i++)
7361f5207b7SJohn Levon 			continue;
7371f5207b7SJohn Levon 		if  (stmt->pos.line == get_lineno())
7381f5207b7SJohn Levon 			return 1;
7391f5207b7SJohn Levon 		return 0;
7401f5207b7SJohn Levon 	} END_FOR_EACH_PTR_REVERSE(stmt);
7411f5207b7SJohn Levon 	return 0;
7421f5207b7SJohn Levon }
7431f5207b7SJohn Levon 
split_asm_constraints(struct expression_list * expr_list)7441f5207b7SJohn Levon static void split_asm_constraints(struct expression_list *expr_list)
7451f5207b7SJohn Levon {
7461f5207b7SJohn Levon 	struct expression *expr;
7471f5207b7SJohn Levon 	int state = 0;
7481f5207b7SJohn Levon 
7491f5207b7SJohn Levon 	FOR_EACH_PTR(expr_list, expr) {
7501f5207b7SJohn Levon 		switch (state) {
7511f5207b7SJohn Levon 		case 0: /* identifier */
7521f5207b7SJohn Levon 		case 1: /* constraint */
7531f5207b7SJohn Levon 			state++;
7541f5207b7SJohn Levon 			continue;
7551f5207b7SJohn Levon 		case 2: /* expression */
7561f5207b7SJohn Levon 			state = 0;
7571f5207b7SJohn Levon 			__split_expr(expr);
7581f5207b7SJohn Levon 			continue;
7591f5207b7SJohn Levon 		}
7601f5207b7SJohn Levon 	} END_FOR_EACH_PTR(expr);
7611f5207b7SJohn Levon }
7621f5207b7SJohn Levon 
is_case_val(struct statement * stmt,sval_t sval)7631f5207b7SJohn Levon static int is_case_val(struct statement *stmt, sval_t sval)
7641f5207b7SJohn Levon {
7651f5207b7SJohn Levon 	sval_t case_sval;
7661f5207b7SJohn Levon 
7671f5207b7SJohn Levon 	if (stmt->type != STMT_CASE)
7681f5207b7SJohn Levon 		return 0;
7691f5207b7SJohn Levon 	if (!stmt->case_expression) {
7701f5207b7SJohn Levon 		__set_default();
7711f5207b7SJohn Levon 		return 1;
7721f5207b7SJohn Levon 	}
7731f5207b7SJohn Levon 	if (!get_value(stmt->case_expression, &case_sval))
7741f5207b7SJohn Levon 		return 0;
7751f5207b7SJohn Levon 	if (case_sval.value == sval.value)
7761f5207b7SJohn Levon 		return 1;
7771f5207b7SJohn Levon 	return 0;
7781f5207b7SJohn Levon }
7791f5207b7SJohn Levon 
get_case_rl(struct expression * switch_expr,struct expression * case_expr,struct expression * case_to)7801f5207b7SJohn Levon static struct range_list *get_case_rl(struct expression *switch_expr,
7811f5207b7SJohn Levon 				      struct expression *case_expr,
7821f5207b7SJohn Levon 				      struct expression *case_to)
7831f5207b7SJohn Levon {
7841f5207b7SJohn Levon 	sval_t start, end;
7851f5207b7SJohn Levon 	struct range_list *rl = NULL;
7861f5207b7SJohn Levon 	struct symbol *switch_type;
7871f5207b7SJohn Levon 
7881f5207b7SJohn Levon 	switch_type = get_type(switch_expr);
7891f5207b7SJohn Levon 	if (get_value(case_to, &end) && get_value(case_expr, &start)) {
7901f5207b7SJohn Levon 		start = sval_cast(switch_type, start);
7911f5207b7SJohn Levon 		end = sval_cast(switch_type, end);
7921f5207b7SJohn Levon 		add_range(&rl, start, end);
7931f5207b7SJohn Levon 	} else if (get_value(case_expr, &start)) {
7941f5207b7SJohn Levon 		start = sval_cast(switch_type, start);
7951f5207b7SJohn Levon 		add_range(&rl, start, start);
7961f5207b7SJohn Levon 	}
7971f5207b7SJohn Levon 
7981f5207b7SJohn Levon 	return rl;
7991f5207b7SJohn Levon }
8001f5207b7SJohn Levon 
split_known_switch(struct statement * stmt,sval_t sval)8011f5207b7SJohn Levon static void split_known_switch(struct statement *stmt, sval_t sval)
8021f5207b7SJohn Levon {
8031f5207b7SJohn Levon 	struct statement *tmp;
8041f5207b7SJohn Levon 	struct range_list *rl;
8051f5207b7SJohn Levon 
8061f5207b7SJohn Levon 	__split_expr(stmt->switch_expression);
8071f5207b7SJohn Levon 	sval = sval_cast(get_type(stmt->switch_expression), sval);
8081f5207b7SJohn Levon 
8091f5207b7SJohn Levon 	push_expression(&switch_expr_stack, stmt->switch_expression);
8101f5207b7SJohn Levon 	__save_switch_states(top_expression(switch_expr_stack));
8111f5207b7SJohn Levon 	nullify_path();
8121f5207b7SJohn Levon 	__push_default();
8131f5207b7SJohn Levon 	__push_breaks();
8141f5207b7SJohn Levon 
8151f5207b7SJohn Levon 	stmt = stmt->switch_statement;
8161f5207b7SJohn Levon 
8171f5207b7SJohn Levon 	__push_scope_hooks();
8181f5207b7SJohn Levon 	FOR_EACH_PTR(stmt->stmts, tmp) {
8191f5207b7SJohn Levon 		__smatch_lineno = tmp->pos.line;
8201f5207b7SJohn Levon 		if (is_case_val(tmp, sval)) {
8211f5207b7SJohn Levon 			rl = alloc_rl(sval, sval);
8221f5207b7SJohn Levon 			__merge_switches(top_expression(switch_expr_stack), rl);
8231f5207b7SJohn Levon 			__pass_case_to_client(top_expression(switch_expr_stack), rl);
8241f5207b7SJohn Levon 		}
8251f5207b7SJohn Levon 		if (__path_is_null())
8261f5207b7SJohn Levon 			continue;
8271f5207b7SJohn Levon 		__split_stmt(tmp);
8281f5207b7SJohn Levon 		if (__path_is_null()) {
8291f5207b7SJohn Levon 			__set_default();
8301f5207b7SJohn Levon 			goto out;
8311f5207b7SJohn Levon 		}
8321f5207b7SJohn Levon 	} END_FOR_EACH_PTR(tmp);
8331f5207b7SJohn Levon out:
8341f5207b7SJohn Levon 	__call_scope_hooks();
8351f5207b7SJohn Levon 	if (!__pop_default())
8361f5207b7SJohn Levon 		__merge_switches(top_expression(switch_expr_stack), NULL);
8371f5207b7SJohn Levon 	__discard_switches();
8381f5207b7SJohn Levon 	__merge_breaks();
8391f5207b7SJohn Levon 	pop_expression(&switch_expr_stack);
8401f5207b7SJohn Levon }
8411f5207b7SJohn Levon 
split_case(struct statement * stmt)8421f5207b7SJohn Levon static void split_case(struct statement *stmt)
8431f5207b7SJohn Levon {
8441f5207b7SJohn Levon 	struct range_list *rl = NULL;
8451f5207b7SJohn Levon 
8461f5207b7SJohn Levon 	expr_set_parent_stmt(stmt->case_expression, stmt);
8471f5207b7SJohn Levon 	expr_set_parent_stmt(stmt->case_to, stmt);
8481f5207b7SJohn Levon 
8491f5207b7SJohn Levon 	rl = get_case_rl(top_expression(switch_expr_stack),
8501f5207b7SJohn Levon 			 stmt->case_expression, stmt->case_to);
8511f5207b7SJohn Levon 	while (stmt->case_statement->type == STMT_CASE) {
8521f5207b7SJohn Levon 		struct range_list *tmp;
8531f5207b7SJohn Levon 
8541f5207b7SJohn Levon 		tmp = get_case_rl(top_expression(switch_expr_stack),
8551f5207b7SJohn Levon 				  stmt->case_statement->case_expression,
8561f5207b7SJohn Levon 				  stmt->case_statement->case_to);
8571f5207b7SJohn Levon 		if (!tmp)
8581f5207b7SJohn Levon 			break;
8591f5207b7SJohn Levon 		rl = rl_union(rl, tmp);
8601f5207b7SJohn Levon 		if (!stmt->case_expression)
8611f5207b7SJohn Levon 			__set_default();
8621f5207b7SJohn Levon 		stmt = stmt->case_statement;
8631f5207b7SJohn Levon 	}
8641f5207b7SJohn Levon 
8651f5207b7SJohn Levon 	__merge_switches(top_expression(switch_expr_stack), rl);
8661f5207b7SJohn Levon 
8671f5207b7SJohn Levon 	if (!stmt->case_expression)
8681f5207b7SJohn Levon 		__set_default();
8691f5207b7SJohn Levon 	__split_stmt(stmt->case_statement);
8701f5207b7SJohn Levon }
8711f5207b7SJohn Levon 
time_parsing_function(void)8721f5207b7SJohn Levon int time_parsing_function(void)
8731f5207b7SJohn Levon {
8741f5207b7SJohn Levon 	return ms_since(&fn_start_time) / 1000;
8751f5207b7SJohn Levon }
8761f5207b7SJohn Levon 
877efe51d0cSJohn Levon /*
878efe51d0cSJohn Levon  * This defaults to 60 * 5 == 5 minutes, so we'll just multiply
879efe51d0cSJohn Levon  * whatever we're given by 5.
880efe51d0cSJohn Levon  */
taking_too_long(void)881efe51d0cSJohn Levon bool taking_too_long(void)
8821f5207b7SJohn Levon {
883efe51d0cSJohn Levon 	if (option_timeout &&
884efe51d0cSJohn Levon 	    (ms_since(&outer_fn_start_time) / 1000) > option_timeout * 5)
8851f5207b7SJohn Levon 		return 1;
8861f5207b7SJohn Levon 	return 0;
8871f5207b7SJohn Levon }
8881f5207b7SJohn Levon 
is_last_stmt(struct statement * cur_stmt)8891f5207b7SJohn Levon static int is_last_stmt(struct statement *cur_stmt)
8901f5207b7SJohn Levon {
8911f5207b7SJohn Levon 	struct symbol *fn;
8921f5207b7SJohn Levon 	struct statement *stmt;
8931f5207b7SJohn Levon 
8941f5207b7SJohn Levon 	if (!cur_func_sym)
8951f5207b7SJohn Levon 		return 0;
8961f5207b7SJohn Levon 	fn = get_base_type(cur_func_sym);
8971f5207b7SJohn Levon 	if (!fn)
8981f5207b7SJohn Levon 		return 0;
8991f5207b7SJohn Levon 	stmt = fn->stmt;
9001f5207b7SJohn Levon 	if (!stmt)
9011f5207b7SJohn Levon 		stmt = fn->inline_stmt;
9021f5207b7SJohn Levon 	if (!stmt || stmt->type != STMT_COMPOUND)
9031f5207b7SJohn Levon 		return 0;
9041f5207b7SJohn Levon 	stmt = last_ptr_list((struct ptr_list *)stmt->stmts);
9051f5207b7SJohn Levon 	if (stmt && stmt->type == STMT_LABEL)
9061f5207b7SJohn Levon 		stmt = stmt->label_statement;
9071f5207b7SJohn Levon 	if (stmt == cur_stmt)
9081f5207b7SJohn Levon 		return 1;
9091f5207b7SJohn Levon 	return 0;
9101f5207b7SJohn Levon }
9111f5207b7SJohn Levon 
handle_backward_goto(struct statement * goto_stmt)9121f5207b7SJohn Levon static void handle_backward_goto(struct statement *goto_stmt)
9131f5207b7SJohn Levon {
9141f5207b7SJohn Levon 	const char *goto_name, *label_name;
9151f5207b7SJohn Levon 	struct statement *func_stmt;
9161f5207b7SJohn Levon 	struct symbol *base_type = get_base_type(cur_func_sym);
9171f5207b7SJohn Levon 	struct statement *tmp;
9181f5207b7SJohn Levon 	int found = 0;
9191f5207b7SJohn Levon 
9201f5207b7SJohn Levon 	if (!option_info)
9211f5207b7SJohn Levon 		return;
9221f5207b7SJohn Levon 	if (last_goto_statement_handled)
9231f5207b7SJohn Levon 		return;
9241f5207b7SJohn Levon 	last_goto_statement_handled = 1;
9251f5207b7SJohn Levon 
9261f5207b7SJohn Levon 	if (!goto_stmt->goto_label ||
9271f5207b7SJohn Levon 	    goto_stmt->goto_label->type != SYM_LABEL ||
9281f5207b7SJohn Levon 	    !goto_stmt->goto_label->ident)
9291f5207b7SJohn Levon 		return;
9301f5207b7SJohn Levon 	goto_name = goto_stmt->goto_label->ident->name;
9311f5207b7SJohn Levon 
9321f5207b7SJohn Levon 	func_stmt = base_type->stmt;
9331f5207b7SJohn Levon 	if (!func_stmt)
9341f5207b7SJohn Levon 		func_stmt = base_type->inline_stmt;
9351f5207b7SJohn Levon 	if (!func_stmt)
9361f5207b7SJohn Levon 		return;
9371f5207b7SJohn Levon 	if (func_stmt->type != STMT_COMPOUND)
9381f5207b7SJohn Levon 		return;
9391f5207b7SJohn Levon 
9401f5207b7SJohn Levon 	FOR_EACH_PTR(func_stmt->stmts, tmp) {
9411f5207b7SJohn Levon 		if (!found) {
9421f5207b7SJohn Levon 			if (tmp->type != STMT_LABEL)
9431f5207b7SJohn Levon 				continue;
9441f5207b7SJohn Levon 			if (!tmp->label_identifier ||
9451f5207b7SJohn Levon 			    tmp->label_identifier->type != SYM_LABEL ||
9461f5207b7SJohn Levon 			    !tmp->label_identifier->ident)
9471f5207b7SJohn Levon 				continue;
9481f5207b7SJohn Levon 			label_name = tmp->label_identifier->ident->name;
9491f5207b7SJohn Levon 			if (strcmp(goto_name, label_name) != 0)
9501f5207b7SJohn Levon 				continue;
9511f5207b7SJohn Levon 			found = 1;
9521f5207b7SJohn Levon 		}
9531f5207b7SJohn Levon 		__split_stmt(tmp);
9541f5207b7SJohn Levon 	} END_FOR_EACH_PTR(tmp);
9551f5207b7SJohn Levon }
9561f5207b7SJohn Levon 
fake_a_return(void)9571f5207b7SJohn Levon static void fake_a_return(void)
9581f5207b7SJohn Levon {
9591f5207b7SJohn Levon 	struct symbol *return_type;
9601f5207b7SJohn Levon 
9611f5207b7SJohn Levon 	nullify_path();
9621f5207b7SJohn Levon 	__unnullify_path();
9631f5207b7SJohn Levon 
9641f5207b7SJohn Levon 	return_type = get_real_base_type(cur_func_sym);
9651f5207b7SJohn Levon 	return_type = get_real_base_type(return_type);
9661f5207b7SJohn Levon 	if (return_type != &void_ctype) {
9671f5207b7SJohn Levon 		__pass_to_client(unknown_value_expression(NULL), RETURN_HOOK);
9681f5207b7SJohn Levon 		nullify_path();
9691f5207b7SJohn Levon 	}
9701f5207b7SJohn Levon }
9711f5207b7SJohn Levon 
fake_an_empty_default(struct position pos)9721f5207b7SJohn Levon static void fake_an_empty_default(struct position pos)
9731f5207b7SJohn Levon {
9741f5207b7SJohn Levon 	static struct statement none = {};
9751f5207b7SJohn Levon 
9761f5207b7SJohn Levon 	none.pos = pos;
9771f5207b7SJohn Levon 	none.type = STMT_NONE;
9781f5207b7SJohn Levon 	__merge_switches(top_expression(switch_expr_stack), NULL);
9791f5207b7SJohn Levon 	__split_stmt(&none);
9801f5207b7SJohn Levon }
9811f5207b7SJohn Levon 
split_compound(struct statement * stmt)9821f5207b7SJohn Levon static void split_compound(struct statement *stmt)
9831f5207b7SJohn Levon {
9841f5207b7SJohn Levon 	struct statement *prev = NULL;
9851f5207b7SJohn Levon 	struct statement *cur = NULL;
9861f5207b7SJohn Levon 	struct statement *next;
9871f5207b7SJohn Levon 
9881f5207b7SJohn Levon 	__push_scope_hooks();
9891f5207b7SJohn Levon 
9901f5207b7SJohn Levon 	FOR_EACH_PTR(stmt->stmts, next) {
9911f5207b7SJohn Levon 		/* just set them all ahead of time */
9921f5207b7SJohn Levon 		stmt_set_parent_stmt(next, stmt);
9931f5207b7SJohn Levon 
9941f5207b7SJohn Levon 		if (cur) {
9951f5207b7SJohn Levon 			__prev_stmt = prev;
9961f5207b7SJohn Levon 			__next_stmt = next;
9971f5207b7SJohn Levon 			__cur_stmt = cur;
9981f5207b7SJohn Levon 			__split_stmt(cur);
9991f5207b7SJohn Levon 		}
10001f5207b7SJohn Levon 		prev = cur;
10011f5207b7SJohn Levon 		cur = next;
10021f5207b7SJohn Levon 	} END_FOR_EACH_PTR(next);
10031f5207b7SJohn Levon 	if (cur) {
10041f5207b7SJohn Levon 		__prev_stmt = prev;
10051f5207b7SJohn Levon 		__cur_stmt = cur;
10061f5207b7SJohn Levon 		__next_stmt = NULL;
10071f5207b7SJohn Levon 		__split_stmt(cur);
10081f5207b7SJohn Levon 	}
10091f5207b7SJohn Levon 
10101f5207b7SJohn Levon 	/*
10111f5207b7SJohn Levon 	 * For function scope, then delay calling the scope hooks until the
10121f5207b7SJohn Levon 	 * end of function hooks can run.  I'm not positive this is the right
10131f5207b7SJohn Levon 	 * thing...
10141f5207b7SJohn Levon 	 */
10151f5207b7SJohn Levon 	if (!is_last_stmt(cur))
10161f5207b7SJohn Levon 		__call_scope_hooks();
10171f5207b7SJohn Levon }
10181f5207b7SJohn Levon 
10191f5207b7SJohn Levon /*
10201f5207b7SJohn Levon  * This is a hack, work around for detecting empty functions.
10211f5207b7SJohn Levon  */
need_delayed_scope_hooks(void)10221f5207b7SJohn Levon static int need_delayed_scope_hooks(void)
10231f5207b7SJohn Levon {
10241f5207b7SJohn Levon 	struct symbol *fn = get_base_type(cur_func_sym);
10251f5207b7SJohn Levon 	struct statement *stmt;
10261f5207b7SJohn Levon 
10271f5207b7SJohn Levon 	if (!fn)
10281f5207b7SJohn Levon 		return 0;
10291f5207b7SJohn Levon 	stmt = fn->stmt;
10301f5207b7SJohn Levon 	if (!stmt)
10311f5207b7SJohn Levon 		stmt = fn->inline_stmt;
10321f5207b7SJohn Levon 	if (stmt && stmt->type == STMT_COMPOUND)
10331f5207b7SJohn Levon 		return 1;
10341f5207b7SJohn Levon 	return 0;
10351f5207b7SJohn Levon }
10361f5207b7SJohn Levon 
__split_label_stmt(struct statement * stmt)10371f5207b7SJohn Levon void __split_label_stmt(struct statement *stmt)
10381f5207b7SJohn Levon {
10391f5207b7SJohn Levon 	if (stmt->label_identifier &&
10401f5207b7SJohn Levon 	    stmt->label_identifier->type == SYM_LABEL &&
10411f5207b7SJohn Levon 	    stmt->label_identifier->ident) {
10421f5207b7SJohn Levon 		loop_count |= 0x0800000;
10431f5207b7SJohn Levon 		__merge_gotos(stmt->label_identifier->ident->name, stmt->label_identifier);
10441f5207b7SJohn Levon 	}
10451f5207b7SJohn Levon }
10461f5207b7SJohn Levon 
find_asm_gotos(struct statement * stmt)10471f5207b7SJohn Levon static void find_asm_gotos(struct statement *stmt)
10481f5207b7SJohn Levon {
10491f5207b7SJohn Levon 	struct symbol *sym;
10501f5207b7SJohn Levon 
10511f5207b7SJohn Levon 	FOR_EACH_PTR(stmt->asm_labels, sym) {
10521f5207b7SJohn Levon 		__save_gotos(sym->ident->name, sym);
10531f5207b7SJohn Levon 	} END_FOR_EACH_PTR(sym);
10541f5207b7SJohn Levon }
10551f5207b7SJohn Levon 
__split_stmt(struct statement * stmt)10561f5207b7SJohn Levon void __split_stmt(struct statement *stmt)
10571f5207b7SJohn Levon {
10581f5207b7SJohn Levon 	sval_t sval;
10591f5207b7SJohn Levon 
10601f5207b7SJohn Levon 	if (!stmt)
10611f5207b7SJohn Levon 		goto out;
10621f5207b7SJohn Levon 
10631f5207b7SJohn Levon 	if (!__in_fake_assign)
10641f5207b7SJohn Levon 		__silence_warnings_for_stmt = false;
10651f5207b7SJohn Levon 
10661f5207b7SJohn Levon 	if (__bail_on_rest_of_function || is_skipped_function())
10671f5207b7SJohn Levon 		return;
10681f5207b7SJohn Levon 
10691f5207b7SJohn Levon 	if (out_of_memory() || taking_too_long()) {
10701f5207b7SJohn Levon 		struct timeval stop;
10711f5207b7SJohn Levon 
10721f5207b7SJohn Levon 		gettimeofday(&stop, NULL);
10731f5207b7SJohn Levon 
10741f5207b7SJohn Levon 		__bail_on_rest_of_function = 1;
10751f5207b7SJohn Levon 		final_pass = 1;
10761f5207b7SJohn Levon 		sm_perror("Function too hairy.  Giving up. %lu seconds",
10771f5207b7SJohn Levon 		       stop.tv_sec - fn_start_time.tv_sec);
10781f5207b7SJohn Levon 		fake_a_return();
10791f5207b7SJohn Levon 		final_pass = 0;  /* turn off sm_msg() from here */
10801f5207b7SJohn Levon 		return;
10811f5207b7SJohn Levon 	}
10821f5207b7SJohn Levon 
10831f5207b7SJohn Levon 	add_ptr_list(&big_statement_stack, stmt);
10841f5207b7SJohn Levon 	free_expression_stack(&big_expression_stack);
10851f5207b7SJohn Levon 	set_position(stmt->pos);
10861f5207b7SJohn Levon 	__pass_to_client(stmt, STMT_HOOK);
10871f5207b7SJohn Levon 
10881f5207b7SJohn Levon 	switch (stmt->type) {
10891f5207b7SJohn Levon 	case STMT_DECLARATION:
10901f5207b7SJohn Levon 		split_declaration(stmt->declaration);
10911f5207b7SJohn Levon 		break;
10921f5207b7SJohn Levon 	case STMT_RETURN:
10931f5207b7SJohn Levon 		expr_set_parent_stmt(stmt->ret_value, stmt);
10941f5207b7SJohn Levon 
10951f5207b7SJohn Levon 		__split_expr(stmt->ret_value);
10961f5207b7SJohn Levon 		__pass_to_client(stmt->ret_value, RETURN_HOOK);
10971f5207b7SJohn Levon 		__process_post_op_stack();
10981f5207b7SJohn Levon 		nullify_path();
10991f5207b7SJohn Levon 		break;
11001f5207b7SJohn Levon 	case STMT_EXPRESSION:
11011f5207b7SJohn Levon 		expr_set_parent_stmt(stmt->expression, stmt);
11021f5207b7SJohn Levon 		expr_set_parent_stmt(stmt->context, stmt);
11031f5207b7SJohn Levon 
11041f5207b7SJohn Levon 		__split_expr(stmt->expression);
11051f5207b7SJohn Levon 		break;
11061f5207b7SJohn Levon 	case STMT_COMPOUND:
11071f5207b7SJohn Levon 		split_compound(stmt);
11081f5207b7SJohn Levon 		break;
11091f5207b7SJohn Levon 	case STMT_IF:
11101f5207b7SJohn Levon 		stmt_set_parent_stmt(stmt->if_true, stmt);
11111f5207b7SJohn Levon 		stmt_set_parent_stmt(stmt->if_false, stmt);
11121f5207b7SJohn Levon 		expr_set_parent_stmt(stmt->if_conditional, stmt);
11131f5207b7SJohn Levon 
11141f5207b7SJohn Levon 		if (known_condition_true(stmt->if_conditional)) {
11151f5207b7SJohn Levon 			__split_stmt(stmt->if_true);
11161f5207b7SJohn Levon 			break;
11171f5207b7SJohn Levon 		}
11181f5207b7SJohn Levon 		if (known_condition_false(stmt->if_conditional)) {
11191f5207b7SJohn Levon 			__split_stmt(stmt->if_false);
11201f5207b7SJohn Levon 			break;
11211f5207b7SJohn Levon 		}
11221f5207b7SJohn Levon 		__split_whole_condition(stmt->if_conditional);
11231f5207b7SJohn Levon 		__split_stmt(stmt->if_true);
11241f5207b7SJohn Levon 		if (empty_statement(stmt->if_true) &&
11251f5207b7SJohn Levon 			last_stmt_on_same_line() &&
11261f5207b7SJohn Levon 			!get_macro_name(stmt->if_true->pos))
11271f5207b7SJohn Levon 			sm_warning("if();");
11281f5207b7SJohn Levon 		__push_true_states();
11291f5207b7SJohn Levon 		__use_false_states();
11301f5207b7SJohn Levon 		__split_stmt(stmt->if_false);
11311f5207b7SJohn Levon 		__merge_true_states();
11321f5207b7SJohn Levon 		break;
11331f5207b7SJohn Levon 	case STMT_ITERATOR:
11341f5207b7SJohn Levon 		stmt_set_parent_stmt(stmt->iterator_pre_statement, stmt);
11351f5207b7SJohn Levon 		stmt_set_parent_stmt(stmt->iterator_statement, stmt);
11361f5207b7SJohn Levon 		stmt_set_parent_stmt(stmt->iterator_post_statement, stmt);
11371f5207b7SJohn Levon 		expr_set_parent_stmt(stmt->iterator_pre_condition, stmt);
11381f5207b7SJohn Levon 		expr_set_parent_stmt(stmt->iterator_post_condition, stmt);
11391f5207b7SJohn Levon 
11401f5207b7SJohn Levon 		if (stmt->iterator_pre_condition)
11411f5207b7SJohn Levon 			handle_pre_loop(stmt);
11421f5207b7SJohn Levon 		else if (stmt->iterator_post_condition)
11431f5207b7SJohn Levon 			handle_post_loop(stmt);
11441f5207b7SJohn Levon 		else {
11451f5207b7SJohn Levon 			// these are for(;;) type loops.
11461f5207b7SJohn Levon 			handle_pre_loop(stmt);
11471f5207b7SJohn Levon 		}
11481f5207b7SJohn Levon 		break;
11491f5207b7SJohn Levon 	case STMT_SWITCH:
11501f5207b7SJohn Levon 		stmt_set_parent_stmt(stmt->switch_statement, stmt);
11511f5207b7SJohn Levon 		expr_set_parent_stmt(stmt->switch_expression, stmt);
11521f5207b7SJohn Levon 
11531f5207b7SJohn Levon 		if (get_value(stmt->switch_expression, &sval)) {
11541f5207b7SJohn Levon 			split_known_switch(stmt, sval);
11551f5207b7SJohn Levon 			break;
11561f5207b7SJohn Levon 		}
11571f5207b7SJohn Levon 		__split_expr(stmt->switch_expression);
11581f5207b7SJohn Levon 		push_expression(&switch_expr_stack, stmt->switch_expression);
11591f5207b7SJohn Levon 		__save_switch_states(top_expression(switch_expr_stack));
11601f5207b7SJohn Levon 		nullify_path();
11611f5207b7SJohn Levon 		__push_default();
11621f5207b7SJohn Levon 		__push_breaks();
11631f5207b7SJohn Levon 		__split_stmt(stmt->switch_statement);
11641f5207b7SJohn Levon 		if (!__pop_default() && have_remaining_cases())
11651f5207b7SJohn Levon 			fake_an_empty_default(stmt->pos);
11661f5207b7SJohn Levon 		__discard_switches();
11671f5207b7SJohn Levon 		__merge_breaks();
11681f5207b7SJohn Levon 		pop_expression(&switch_expr_stack);
11691f5207b7SJohn Levon 		break;
11701f5207b7SJohn Levon 	case STMT_CASE:
11711f5207b7SJohn Levon 		split_case(stmt);
11721f5207b7SJohn Levon 		break;
11731f5207b7SJohn Levon 	case STMT_LABEL:
11741f5207b7SJohn Levon 		__split_label_stmt(stmt);
11751f5207b7SJohn Levon 		__split_stmt(stmt->label_statement);
11761f5207b7SJohn Levon 		break;
11771f5207b7SJohn Levon 	case STMT_GOTO:
11781f5207b7SJohn Levon 		expr_set_parent_stmt(stmt->goto_expression, stmt);
11791f5207b7SJohn Levon 
11801f5207b7SJohn Levon 		__split_expr(stmt->goto_expression);
11811f5207b7SJohn Levon 		if (stmt->goto_label && stmt->goto_label->type == SYM_NODE) {
11821f5207b7SJohn Levon 			if (!strcmp(stmt->goto_label->ident->name, "break")) {
11831f5207b7SJohn Levon 				__process_breaks();
11841f5207b7SJohn Levon 			} else if (!strcmp(stmt->goto_label->ident->name,
11851f5207b7SJohn Levon 					   "continue")) {
11861f5207b7SJohn Levon 				__process_continues();
11871f5207b7SJohn Levon 			}
11881f5207b7SJohn Levon 		} else if (stmt->goto_label &&
11891f5207b7SJohn Levon 			   stmt->goto_label->type == SYM_LABEL &&
11901f5207b7SJohn Levon 			   stmt->goto_label->ident) {
11911f5207b7SJohn Levon 			__save_gotos(stmt->goto_label->ident->name, stmt->goto_label);
11921f5207b7SJohn Levon 		}
11931f5207b7SJohn Levon 		nullify_path();
11941f5207b7SJohn Levon 		if (is_last_stmt(stmt))
11951f5207b7SJohn Levon 			handle_backward_goto(stmt);
11961f5207b7SJohn Levon 		break;
11971f5207b7SJohn Levon 	case STMT_NONE:
11981f5207b7SJohn Levon 		break;
11991f5207b7SJohn Levon 	case STMT_ASM:
12001f5207b7SJohn Levon 		expr_set_parent_stmt(stmt->asm_string, stmt);
12011f5207b7SJohn Levon 
12021f5207b7SJohn Levon 		find_asm_gotos(stmt);
12031f5207b7SJohn Levon 		__pass_to_client(stmt, ASM_HOOK);
12041f5207b7SJohn Levon 		__split_expr(stmt->asm_string);
12051f5207b7SJohn Levon 		split_asm_constraints(stmt->asm_outputs);
12061f5207b7SJohn Levon 		split_asm_constraints(stmt->asm_inputs);
12071f5207b7SJohn Levon 		split_asm_constraints(stmt->asm_clobbers);
12081f5207b7SJohn Levon 		break;
12091f5207b7SJohn Levon 	case STMT_CONTEXT:
12101f5207b7SJohn Levon 		break;
12111f5207b7SJohn Levon 	case STMT_RANGE:
12121f5207b7SJohn Levon 		__split_expr(stmt->range_expression);
12131f5207b7SJohn Levon 		__split_expr(stmt->range_low);
12141f5207b7SJohn Levon 		__split_expr(stmt->range_high);
12151f5207b7SJohn Levon 		break;
12161f5207b7SJohn Levon 	}
12171f5207b7SJohn Levon 	__pass_to_client(stmt, STMT_HOOK_AFTER);
12181f5207b7SJohn Levon out:
12191f5207b7SJohn Levon 	__process_post_op_stack();
12201f5207b7SJohn Levon }
12211f5207b7SJohn Levon 
split_expr_list(struct expression_list * expr_list,struct expression * parent)12221f5207b7SJohn Levon static void split_expr_list(struct expression_list *expr_list, struct expression *parent)
12231f5207b7SJohn Levon {
12241f5207b7SJohn Levon 	struct expression *expr;
12251f5207b7SJohn Levon 
12261f5207b7SJohn Levon 	FOR_EACH_PTR(expr_list, expr) {
12271f5207b7SJohn Levon 		expr_set_parent_expr(expr, parent);
12281f5207b7SJohn Levon 		__split_expr(expr);
12291f5207b7SJohn Levon 		__process_post_op_stack();
12301f5207b7SJohn Levon 	} END_FOR_EACH_PTR(expr);
12311f5207b7SJohn Levon }
12321f5207b7SJohn Levon 
split_sym(struct symbol * sym)12331f5207b7SJohn Levon static void split_sym(struct symbol *sym)
12341f5207b7SJohn Levon {
12351f5207b7SJohn Levon 	if (!sym)
12361f5207b7SJohn Levon 		return;
12371f5207b7SJohn Levon 	if (!(sym->namespace & NS_SYMBOL))
12381f5207b7SJohn Levon 		return;
12391f5207b7SJohn Levon 
12401f5207b7SJohn Levon 	__split_stmt(sym->stmt);
12411f5207b7SJohn Levon 	__split_expr(sym->array_size);
12421f5207b7SJohn Levon 	split_symlist(sym->arguments);
12431f5207b7SJohn Levon 	split_symlist(sym->symbol_list);
12441f5207b7SJohn Levon 	__split_stmt(sym->inline_stmt);
12451f5207b7SJohn Levon 	split_symlist(sym->inline_symbol_list);
12461f5207b7SJohn Levon }
12471f5207b7SJohn Levon 
split_symlist(struct symbol_list * sym_list)12481f5207b7SJohn Levon static void split_symlist(struct symbol_list *sym_list)
12491f5207b7SJohn Levon {
12501f5207b7SJohn Levon 	struct symbol *sym;
12511f5207b7SJohn Levon 
12521f5207b7SJohn Levon 	FOR_EACH_PTR(sym_list, sym) {
12531f5207b7SJohn Levon 		split_sym(sym);
12541f5207b7SJohn Levon 	} END_FOR_EACH_PTR(sym);
12551f5207b7SJohn Levon }
12561f5207b7SJohn Levon 
12571f5207b7SJohn Levon typedef void (fake_cb)(struct expression *expr);
12581f5207b7SJohn Levon 
member_to_number(struct expression * expr,struct ident * member)12591f5207b7SJohn Levon static int member_to_number(struct expression *expr, struct ident *member)
12601f5207b7SJohn Levon {
12611f5207b7SJohn Levon 	struct symbol *type, *tmp;
12621f5207b7SJohn Levon 	char *name;
12631f5207b7SJohn Levon 	int i;
12641f5207b7SJohn Levon 
12651f5207b7SJohn Levon 	if (!member)
12661f5207b7SJohn Levon 		return -1;
12671f5207b7SJohn Levon 	name = member->name;
12681f5207b7SJohn Levon 
12691f5207b7SJohn Levon 	type = get_type(expr);
12701f5207b7SJohn Levon 	if (!type || type->type != SYM_STRUCT)
12711f5207b7SJohn Levon 		return -1;
12721f5207b7SJohn Levon 
12731f5207b7SJohn Levon 	i = -1;
12741f5207b7SJohn Levon 	FOR_EACH_PTR(type->symbol_list, tmp) {
12751f5207b7SJohn Levon 		i++;
12761f5207b7SJohn Levon 		if (!tmp->ident)
12771f5207b7SJohn Levon 			continue;
12781f5207b7SJohn Levon 		if (strcmp(name, tmp->ident->name) == 0)
12791f5207b7SJohn Levon 			return i;
12801f5207b7SJohn Levon 	} END_FOR_EACH_PTR(tmp);
12811f5207b7SJohn Levon 	return -1;
12821f5207b7SJohn Levon }
12831f5207b7SJohn Levon 
number_to_member(struct expression * expr,int num)12841f5207b7SJohn Levon static struct ident *number_to_member(struct expression *expr, int num)
12851f5207b7SJohn Levon {
12861f5207b7SJohn Levon 	struct symbol *type, *member;
12871f5207b7SJohn Levon 	int i = 0;
12881f5207b7SJohn Levon 
12891f5207b7SJohn Levon 	type = get_type(expr);
12901f5207b7SJohn Levon 	if (!type || type->type != SYM_STRUCT)
12911f5207b7SJohn Levon 		return NULL;
12921f5207b7SJohn Levon 
12931f5207b7SJohn Levon 	FOR_EACH_PTR(type->symbol_list, member) {
12941f5207b7SJohn Levon 		if (i == num)
12951f5207b7SJohn Levon 			return member->ident;
12961f5207b7SJohn Levon 		i++;
12971f5207b7SJohn Levon 	} END_FOR_EACH_PTR(member);
12981f5207b7SJohn Levon 	return NULL;
12991f5207b7SJohn Levon }
13001f5207b7SJohn Levon 
13011f5207b7SJohn Levon static void fake_element_assigns_helper(struct expression *array, struct expression_list *expr_list, fake_cb *fake_cb);
13021f5207b7SJohn Levon 
set_inner_struct_members(struct expression * expr,struct symbol * member)13031f5207b7SJohn Levon static void set_inner_struct_members(struct expression *expr, struct symbol *member)
13041f5207b7SJohn Levon {
13051f5207b7SJohn Levon 	struct expression *edge_member, *assign;
13061f5207b7SJohn Levon 	struct symbol *base = get_real_base_type(member);
13071f5207b7SJohn Levon 	struct symbol *tmp;
13081f5207b7SJohn Levon 
13091f5207b7SJohn Levon 	if (member->ident)
13101f5207b7SJohn Levon 		expr = member_expression(expr, '.', member->ident);
13111f5207b7SJohn Levon 
13121f5207b7SJohn Levon 	FOR_EACH_PTR(base->symbol_list, tmp) {
13131f5207b7SJohn Levon 		struct symbol *type;
13141f5207b7SJohn Levon 
13151f5207b7SJohn Levon 		type = get_real_base_type(tmp);
13161f5207b7SJohn Levon 		if (!type)
13171f5207b7SJohn Levon 			continue;
13181f5207b7SJohn Levon 
13191f5207b7SJohn Levon 		edge_member = member_expression(expr, '.', tmp->ident);
13201f5207b7SJohn Levon 		if (get_extra_state(edge_member))
13211f5207b7SJohn Levon 			continue;
13221f5207b7SJohn Levon 
13231f5207b7SJohn Levon 		if (type->type == SYM_UNION || type->type == SYM_STRUCT) {
13241f5207b7SJohn Levon 			set_inner_struct_members(expr, tmp);
13251f5207b7SJohn Levon 			continue;
13261f5207b7SJohn Levon 		}
13271f5207b7SJohn Levon 
13281f5207b7SJohn Levon 		if (!tmp->ident)
13291f5207b7SJohn Levon 			continue;
13301f5207b7SJohn Levon 
13311f5207b7SJohn Levon 		assign = assign_expression(edge_member, '=', zero_expr());
13321f5207b7SJohn Levon 		__split_expr(assign);
13331f5207b7SJohn Levon 	} END_FOR_EACH_PTR(tmp);
13341f5207b7SJohn Levon 
13351f5207b7SJohn Levon 
13361f5207b7SJohn Levon }
13371f5207b7SJohn Levon 
set_unset_to_zero(struct symbol * type,struct expression * expr)13381f5207b7SJohn Levon static void set_unset_to_zero(struct symbol *type, struct expression *expr)
13391f5207b7SJohn Levon {
13401f5207b7SJohn Levon 	struct symbol *tmp;
13411f5207b7SJohn Levon 	struct expression *member = NULL;
13421f5207b7SJohn Levon 	struct expression *assign;
13431f5207b7SJohn Levon 	int op = '*';
13441f5207b7SJohn Levon 
13451f5207b7SJohn Levon 	if (expr->type == EXPR_PREOP && expr->op == '&') {
13461f5207b7SJohn Levon 		expr = strip_expr(expr->unop);
13471f5207b7SJohn Levon 		op = '.';
13481f5207b7SJohn Levon 	}
13491f5207b7SJohn Levon 
13501f5207b7SJohn Levon 	FOR_EACH_PTR(type->symbol_list, tmp) {
13511f5207b7SJohn Levon 		type = get_real_base_type(tmp);
13521f5207b7SJohn Levon 		if (!type)
13531f5207b7SJohn Levon 			continue;
13541f5207b7SJohn Levon 
13551f5207b7SJohn Levon 		if (tmp->ident) {
13561f5207b7SJohn Levon 			member = member_expression(expr, op, tmp->ident);
13571f5207b7SJohn Levon 			if (get_extra_state(member))
13581f5207b7SJohn Levon 				continue;
13591f5207b7SJohn Levon 		}
13601f5207b7SJohn Levon 
13611f5207b7SJohn Levon 		if (type->type == SYM_UNION || type->type == SYM_STRUCT) {
13621f5207b7SJohn Levon 			set_inner_struct_members(expr, tmp);
13631f5207b7SJohn Levon 			continue;
13641f5207b7SJohn Levon 		}
13651f5207b7SJohn Levon 		if (type->type == SYM_ARRAY)
13661f5207b7SJohn Levon 			continue;
13671f5207b7SJohn Levon 		if (!tmp->ident)
13681f5207b7SJohn Levon 			continue;
13691f5207b7SJohn Levon 
13701f5207b7SJohn Levon 		assign = assign_expression(member, '=', zero_expr());
13711f5207b7SJohn Levon 		__split_expr(assign);
13721f5207b7SJohn Levon 	} END_FOR_EACH_PTR(tmp);
13731f5207b7SJohn Levon }
13741f5207b7SJohn Levon 
fake_member_assigns_helper(struct expression * symbol,struct expression_list * members,fake_cb * fake_cb)13751f5207b7SJohn Levon static void fake_member_assigns_helper(struct expression *symbol, struct expression_list *members, fake_cb *fake_cb)
13761f5207b7SJohn Levon {
13771f5207b7SJohn Levon 	struct expression *deref, *assign, *tmp, *right;
13781f5207b7SJohn Levon 	struct symbol *struct_type, *type;
13791f5207b7SJohn Levon 	struct ident *member;
13801f5207b7SJohn Levon 	int member_idx;
13811f5207b7SJohn Levon 
13821f5207b7SJohn Levon 	struct_type = get_type(symbol);
13831f5207b7SJohn Levon 	if (!struct_type ||
13841f5207b7SJohn Levon 	    (struct_type->type != SYM_STRUCT && struct_type->type != SYM_UNION))
13851f5207b7SJohn Levon 		return;
13861f5207b7SJohn Levon 
13871f5207b7SJohn Levon 	/*
13881f5207b7SJohn Levon 	 * We're parsing an initializer that could look something like this:
13891f5207b7SJohn Levon 	 * struct foo foo = {
13901f5207b7SJohn Levon 	 *	42,
13911f5207b7SJohn Levon 	 *	.whatever.xxx = 11,
13921f5207b7SJohn Levon 	 *	.zzz = 12,
13931f5207b7SJohn Levon 	 * };
13941f5207b7SJohn Levon 	 *
13951f5207b7SJohn Levon 	 * So what we have here is a list with 42, .whatever, and .zzz.  We need
13961f5207b7SJohn Levon 	 * to break it up into left and right sides of the assignments.
13971f5207b7SJohn Levon 	 *
13981f5207b7SJohn Levon 	 */
13991f5207b7SJohn Levon 	member_idx = 0;
14001f5207b7SJohn Levon 	FOR_EACH_PTR(members, tmp) {
14011f5207b7SJohn Levon 		deref = NULL;
14021f5207b7SJohn Levon 		if (tmp->type == EXPR_IDENTIFIER) {
14031f5207b7SJohn Levon 			member_idx = member_to_number(symbol, tmp->expr_ident);
14041f5207b7SJohn Levon 			while (tmp->type == EXPR_IDENTIFIER) {
14051f5207b7SJohn Levon 				member = tmp->expr_ident;
14061f5207b7SJohn Levon 				tmp = tmp->ident_expression;
14071f5207b7SJohn Levon 				if (deref)
14081f5207b7SJohn Levon 					deref = member_expression(deref, '.', member);
14091f5207b7SJohn Levon 				else
14101f5207b7SJohn Levon 					deref = member_expression(symbol, '.', member);
14111f5207b7SJohn Levon 			}
14121f5207b7SJohn Levon 		} else {
14131f5207b7SJohn Levon 			member = number_to_member(symbol, member_idx);
14141f5207b7SJohn Levon 			deref = member_expression(symbol, '.', member);
14151f5207b7SJohn Levon 		}
14161f5207b7SJohn Levon 		right = tmp;
14171f5207b7SJohn Levon 		member_idx++;
14181f5207b7SJohn Levon 		if (right->type == EXPR_INITIALIZER) {
14191f5207b7SJohn Levon 			type = get_type(deref);
14201f5207b7SJohn Levon 			if (type && type->type == SYM_ARRAY)
14211f5207b7SJohn Levon 				fake_element_assigns_helper(deref, right->expr_list, fake_cb);
14221f5207b7SJohn Levon 			else
14231f5207b7SJohn Levon 				fake_member_assigns_helper(deref, right->expr_list, fake_cb);
14241f5207b7SJohn Levon 		} else {
14251f5207b7SJohn Levon 			assign = assign_expression(deref, '=', right);
14261f5207b7SJohn Levon 			fake_cb(assign);
14271f5207b7SJohn Levon 		}
14281f5207b7SJohn Levon 	} END_FOR_EACH_PTR(tmp);
14291f5207b7SJohn Levon 
14301f5207b7SJohn Levon 	set_unset_to_zero(struct_type, symbol);
14311f5207b7SJohn Levon }
14321f5207b7SJohn Levon 
fake_member_assigns(struct symbol * sym,fake_cb * fake_cb)14331f5207b7SJohn Levon static void fake_member_assigns(struct symbol *sym, fake_cb *fake_cb)
14341f5207b7SJohn Levon {
14351f5207b7SJohn Levon 	fake_member_assigns_helper(symbol_expression(sym),
14361f5207b7SJohn Levon 				   sym->initializer->expr_list, fake_cb);
14371f5207b7SJohn Levon }
14381f5207b7SJohn Levon 
fake_element_assigns_helper(struct expression * array,struct expression_list * expr_list,fake_cb * fake_cb)14391f5207b7SJohn Levon static void fake_element_assigns_helper(struct expression *array, struct expression_list *expr_list, fake_cb *fake_cb)
14401f5207b7SJohn Levon {
14411f5207b7SJohn Levon 	struct expression *offset, *binop, *assign, *tmp;
14421f5207b7SJohn Levon 	struct symbol *type;
14431f5207b7SJohn Levon 	int idx;
14441f5207b7SJohn Levon 
14451f5207b7SJohn Levon 	if (ptr_list_size((struct ptr_list *)expr_list) > 1000)
14461f5207b7SJohn Levon 		return;
14471f5207b7SJohn Levon 
14481f5207b7SJohn Levon 	idx = 0;
14491f5207b7SJohn Levon 	FOR_EACH_PTR(expr_list, tmp) {
14501f5207b7SJohn Levon 		if (tmp->type == EXPR_INDEX) {
14511f5207b7SJohn Levon 			if (tmp->idx_from != tmp->idx_to)
14521f5207b7SJohn Levon 				return;
14531f5207b7SJohn Levon 			idx = tmp->idx_from;
14541f5207b7SJohn Levon 			if (!tmp->idx_expression)
14551f5207b7SJohn Levon 				goto next;
14561f5207b7SJohn Levon 			tmp = tmp->idx_expression;
14571f5207b7SJohn Levon 		}
14581f5207b7SJohn Levon 		offset = value_expr(idx);
14591f5207b7SJohn Levon 		binop = array_element_expression(array, offset);
14601f5207b7SJohn Levon 		if (tmp->type == EXPR_INITIALIZER) {
14611f5207b7SJohn Levon 			type = get_type(binop);
14621f5207b7SJohn Levon 			if (type && type->type == SYM_ARRAY)
14631f5207b7SJohn Levon 				fake_element_assigns_helper(binop, tmp->expr_list, fake_cb);
14641f5207b7SJohn Levon 			else
14651f5207b7SJohn Levon 				fake_member_assigns_helper(binop, tmp->expr_list, fake_cb);
14661f5207b7SJohn Levon 		} else {
14671f5207b7SJohn Levon 			assign = assign_expression(binop, '=', tmp);
14681f5207b7SJohn Levon 			fake_cb(assign);
14691f5207b7SJohn Levon 		}
14701f5207b7SJohn Levon next:
14711f5207b7SJohn Levon 		idx++;
14721f5207b7SJohn Levon 	} END_FOR_EACH_PTR(tmp);
14731f5207b7SJohn Levon }
14741f5207b7SJohn Levon 
fake_element_assigns(struct symbol * sym,fake_cb * fake_cb)14751f5207b7SJohn Levon static void fake_element_assigns(struct symbol *sym, fake_cb *fake_cb)
14761f5207b7SJohn Levon {
14771f5207b7SJohn Levon 	fake_element_assigns_helper(symbol_expression(sym), sym->initializer->expr_list, fake_cb);
14781f5207b7SJohn Levon }
14791f5207b7SJohn Levon 
fake_assign_expr(struct symbol * sym)14801f5207b7SJohn Levon static void fake_assign_expr(struct symbol *sym)
14811f5207b7SJohn Levon {
14821f5207b7SJohn Levon 	struct expression *assign, *symbol;
14831f5207b7SJohn Levon 
14841f5207b7SJohn Levon 	symbol = symbol_expression(sym);
14851f5207b7SJohn Levon 	assign = assign_expression(symbol, '=', sym->initializer);
14861f5207b7SJohn Levon 	__split_expr(assign);
14871f5207b7SJohn Levon }
14881f5207b7SJohn Levon 
do_initializer_stuff(struct symbol * sym)14891f5207b7SJohn Levon static void do_initializer_stuff(struct symbol *sym)
14901f5207b7SJohn Levon {
14911f5207b7SJohn Levon 	if (!sym->initializer)
14921f5207b7SJohn Levon 		return;
14931f5207b7SJohn Levon 
14941f5207b7SJohn Levon 	if (sym->initializer->type == EXPR_INITIALIZER) {
14951f5207b7SJohn Levon 		if (get_real_base_type(sym)->type == SYM_ARRAY)
14961f5207b7SJohn Levon 			fake_element_assigns(sym, __split_expr);
14971f5207b7SJohn Levon 		else
14981f5207b7SJohn Levon 			fake_member_assigns(sym, __split_expr);
14991f5207b7SJohn Levon 	} else {
15001f5207b7SJohn Levon 		fake_assign_expr(sym);
15011f5207b7SJohn Levon 	}
15021f5207b7SJohn Levon }
15031f5207b7SJohn Levon 
split_declaration(struct symbol_list * sym_list)15041f5207b7SJohn Levon static void split_declaration(struct symbol_list *sym_list)
15051f5207b7SJohn Levon {
15061f5207b7SJohn Levon 	struct symbol *sym;
15071f5207b7SJohn Levon 
15081f5207b7SJohn Levon 	FOR_EACH_PTR(sym_list, sym) {
15091f5207b7SJohn Levon 		__pass_to_client(sym, DECLARATION_HOOK);
15101f5207b7SJohn Levon 		do_initializer_stuff(sym);
15111f5207b7SJohn Levon 		split_sym(sym);
15121f5207b7SJohn Levon 	} END_FOR_EACH_PTR(sym);
15131f5207b7SJohn Levon }
15141f5207b7SJohn Levon 
call_global_assign_hooks(struct expression * assign)15151f5207b7SJohn Levon static void call_global_assign_hooks(struct expression *assign)
15161f5207b7SJohn Levon {
15171f5207b7SJohn Levon 	__pass_to_client(assign, GLOBAL_ASSIGNMENT_HOOK);
15181f5207b7SJohn Levon }
15191f5207b7SJohn Levon 
fake_global_assign(struct symbol * sym)15201f5207b7SJohn Levon static void fake_global_assign(struct symbol *sym)
15211f5207b7SJohn Levon {
15221f5207b7SJohn Levon 	struct expression *assign, *symbol;
15231f5207b7SJohn Levon 
15241f5207b7SJohn Levon 	if (get_real_base_type(sym)->type == SYM_ARRAY) {
15251f5207b7SJohn Levon 		if (sym->initializer && sym->initializer->type == EXPR_INITIALIZER) {
15261f5207b7SJohn Levon 			fake_element_assigns(sym, call_global_assign_hooks);
15271f5207b7SJohn Levon 		} else if (sym->initializer) {
15281f5207b7SJohn Levon 			symbol = symbol_expression(sym);
15291f5207b7SJohn Levon 			assign = assign_expression(symbol, '=', sym->initializer);
15301f5207b7SJohn Levon 			__pass_to_client(assign, GLOBAL_ASSIGNMENT_HOOK);
15311f5207b7SJohn Levon 		} else {
15321f5207b7SJohn Levon 			fake_element_assigns_helper(symbol_expression(sym), NULL, call_global_assign_hooks);
15331f5207b7SJohn Levon 		}
15341f5207b7SJohn Levon 	} else if (get_real_base_type(sym)->type == SYM_STRUCT) {
15351f5207b7SJohn Levon 		if (sym->initializer && sym->initializer->type == EXPR_INITIALIZER) {
15361f5207b7SJohn Levon 			fake_member_assigns(sym, call_global_assign_hooks);
15371f5207b7SJohn Levon 		} else if (sym->initializer) {
15381f5207b7SJohn Levon 			symbol = symbol_expression(sym);
15391f5207b7SJohn Levon 			assign = assign_expression(symbol, '=', sym->initializer);
15401f5207b7SJohn Levon 			__pass_to_client(assign, GLOBAL_ASSIGNMENT_HOOK);
15411f5207b7SJohn Levon 		} else {
15421f5207b7SJohn Levon 			fake_member_assigns_helper(symbol_expression(sym), NULL, call_global_assign_hooks);
15431f5207b7SJohn Levon 		}
15441f5207b7SJohn Levon 	} else {
15451f5207b7SJohn Levon 		symbol = symbol_expression(sym);
15461f5207b7SJohn Levon 		if (sym->initializer) {
15471f5207b7SJohn Levon 			assign = assign_expression(symbol, '=', sym->initializer);
15481f5207b7SJohn Levon 			__split_expr(assign);
15491f5207b7SJohn Levon 		} else {
15501f5207b7SJohn Levon 			assign = assign_expression(symbol, '=', zero_expr());
15511f5207b7SJohn Levon 		}
15521f5207b7SJohn Levon 		__pass_to_client(assign, GLOBAL_ASSIGNMENT_HOOK);
15531f5207b7SJohn Levon 	}
15541f5207b7SJohn Levon }
15551f5207b7SJohn Levon 
start_function_definition(struct symbol * sym)15561f5207b7SJohn Levon static void start_function_definition(struct symbol *sym)
15571f5207b7SJohn Levon {
15581f5207b7SJohn Levon 	__in_function_def = 1;
15591f5207b7SJohn Levon 	__pass_to_client(sym, FUNC_DEF_HOOK);
15601f5207b7SJohn Levon 	__in_function_def = 0;
15611f5207b7SJohn Levon 	__pass_to_client(sym, AFTER_DEF_HOOK);
15621f5207b7SJohn Levon 
15631f5207b7SJohn Levon }
15641f5207b7SJohn Levon 
split_function(struct symbol * sym)15651f5207b7SJohn Levon static void split_function(struct symbol *sym)
15661f5207b7SJohn Levon {
15671f5207b7SJohn Levon 	struct symbol *base_type = get_base_type(sym);
15681f5207b7SJohn Levon 	struct timeval stop;
15691f5207b7SJohn Levon 
15701f5207b7SJohn Levon 	if (!base_type->stmt && !base_type->inline_stmt)
15711f5207b7SJohn Levon 		return;
15721f5207b7SJohn Levon 
15731f5207b7SJohn Levon 	gettimeofday(&outer_fn_start_time, NULL);
15741f5207b7SJohn Levon 	gettimeofday(&fn_start_time, NULL);
15751f5207b7SJohn Levon 	cur_func_sym = sym;
15761f5207b7SJohn Levon 	if (sym->ident)
15771f5207b7SJohn Levon 		cur_func = sym->ident->name;
15781f5207b7SJohn Levon 	set_position(sym->pos);
15791f5207b7SJohn Levon 	loop_count = 0;
15801f5207b7SJohn Levon 	last_goto_statement_handled = 0;
15811f5207b7SJohn Levon 	sm_debug("new function:  %s\n", cur_func);
15821f5207b7SJohn Levon 	__stree_id = 0;
15831f5207b7SJohn Levon 	if (option_two_passes) {
15841f5207b7SJohn Levon 		__unnullify_path();
15851f5207b7SJohn Levon 		loop_num = 0;
15861f5207b7SJohn Levon 		final_pass = 0;
15871f5207b7SJohn Levon 		start_function_definition(sym);
15881f5207b7SJohn Levon 		__split_stmt(base_type->stmt);
15891f5207b7SJohn Levon 		__split_stmt(base_type->inline_stmt);
15901f5207b7SJohn Levon 		nullify_path();
15911f5207b7SJohn Levon 	}
15921f5207b7SJohn Levon 	__unnullify_path();
15931f5207b7SJohn Levon 	loop_num = 0;
15941f5207b7SJohn Levon 	final_pass = 1;
15951f5207b7SJohn Levon 	start_function_definition(sym);
15961f5207b7SJohn Levon 	__split_stmt(base_type->stmt);
15971f5207b7SJohn Levon 	__split_stmt(base_type->inline_stmt);
15981f5207b7SJohn Levon 	__pass_to_client(sym, END_FUNC_HOOK);
15991f5207b7SJohn Levon 	if (need_delayed_scope_hooks())
16001f5207b7SJohn Levon 		__call_scope_hooks();
16011f5207b7SJohn Levon 	__pass_to_client(sym, AFTER_FUNC_HOOK);
16021f5207b7SJohn Levon 
16031f5207b7SJohn Levon 	clear_all_states();
16041f5207b7SJohn Levon 
16051f5207b7SJohn Levon 	gettimeofday(&stop, NULL);
16061f5207b7SJohn Levon 	if (option_time && stop.tv_sec - fn_start_time.tv_sec > 2) {
16071f5207b7SJohn Levon 		final_pass++;
16081f5207b7SJohn Levon 		sm_msg("func_time: %lu", stop.tv_sec - fn_start_time.tv_sec);
16091f5207b7SJohn Levon 		final_pass--;
16101f5207b7SJohn Levon 	}
16111f5207b7SJohn Levon 	cur_func_sym = NULL;
16121f5207b7SJohn Levon 	cur_func = NULL;
16131f5207b7SJohn Levon 	free_data_info_allocs();
16141f5207b7SJohn Levon 	free_expression_stack(&switch_expr_stack);
16151f5207b7SJohn Levon 	__free_ptr_list((struct ptr_list **)&big_statement_stack);
16161f5207b7SJohn Levon 	__bail_on_rest_of_function = 0;
16171f5207b7SJohn Levon }
16181f5207b7SJohn Levon 
save_flow_state(void)16191f5207b7SJohn Levon static void save_flow_state(void)
16201f5207b7SJohn Levon {
1621c85f09ccSJohn Levon 	__add_ptr_list(&backup, INT_PTR(loop_num << 2));
1622c85f09ccSJohn Levon 	__add_ptr_list(&backup, INT_PTR(loop_count << 2));
1623c85f09ccSJohn Levon 	__add_ptr_list(&backup, INT_PTR(final_pass << 2));
16241f5207b7SJohn Levon 
1625c85f09ccSJohn Levon 	__add_ptr_list(&backup, big_statement_stack);
1626c85f09ccSJohn Levon 	__add_ptr_list(&backup, big_expression_stack);
1627c85f09ccSJohn Levon 	__add_ptr_list(&backup, big_condition_stack);
1628c85f09ccSJohn Levon 	__add_ptr_list(&backup, switch_expr_stack);
16291f5207b7SJohn Levon 
1630c85f09ccSJohn Levon 	__add_ptr_list(&backup, cur_func_sym);
16311f5207b7SJohn Levon 
1632c85f09ccSJohn Levon 	__add_ptr_list(&backup, __prev_stmt);
1633c85f09ccSJohn Levon 	__add_ptr_list(&backup, __cur_stmt);
1634c85f09ccSJohn Levon 	__add_ptr_list(&backup, __next_stmt);
16351f5207b7SJohn Levon }
16361f5207b7SJohn Levon 
pop_backup(void)16371f5207b7SJohn Levon static void *pop_backup(void)
16381f5207b7SJohn Levon {
16391f5207b7SJohn Levon 	void *ret;
16401f5207b7SJohn Levon 
16411f5207b7SJohn Levon 	ret = last_ptr_list(backup);
16421f5207b7SJohn Levon 	delete_ptr_list_last(&backup);
16431f5207b7SJohn Levon 	return ret;
16441f5207b7SJohn Levon }
16451f5207b7SJohn Levon 
restore_flow_state(void)16461f5207b7SJohn Levon static void restore_flow_state(void)
16471f5207b7SJohn Levon {
16481f5207b7SJohn Levon 	__next_stmt = pop_backup();
16491f5207b7SJohn Levon 	__cur_stmt = pop_backup();
16501f5207b7SJohn Levon 	__prev_stmt = pop_backup();
16511f5207b7SJohn Levon 
16521f5207b7SJohn Levon 	cur_func_sym = pop_backup();
16531f5207b7SJohn Levon 	switch_expr_stack = pop_backup();
16541f5207b7SJohn Levon 	big_condition_stack = pop_backup();
16551f5207b7SJohn Levon 	big_expression_stack = pop_backup();
16561f5207b7SJohn Levon 	big_statement_stack = pop_backup();
16571f5207b7SJohn Levon 	final_pass = PTR_INT(pop_backup()) >> 2;
16581f5207b7SJohn Levon 	loop_count = PTR_INT(pop_backup()) >> 2;
16591f5207b7SJohn Levon 	loop_num = PTR_INT(pop_backup()) >> 2;
16601f5207b7SJohn Levon }
16611f5207b7SJohn Levon 
parse_inline(struct expression * call)16621f5207b7SJohn Levon static void parse_inline(struct expression *call)
16631f5207b7SJohn Levon {
16641f5207b7SJohn Levon 	struct symbol *base_type;
16651f5207b7SJohn Levon 	char *cur_func_bak = cur_func;  /* not aligned correctly for backup */
16661f5207b7SJohn Levon 	struct timeval time_backup = fn_start_time;
16671f5207b7SJohn Levon 	struct expression *orig_inline = __inline_fn;
16681f5207b7SJohn Levon 	int orig_budget;
16691f5207b7SJohn Levon 
16701f5207b7SJohn Levon 	if (out_of_memory() || taking_too_long())
16711f5207b7SJohn Levon 		return;
16721f5207b7SJohn Levon 
16731f5207b7SJohn Levon 	save_flow_state();
16741f5207b7SJohn Levon 
16751f5207b7SJohn Levon 	__pass_to_client(call, INLINE_FN_START);
16761f5207b7SJohn Levon 	final_pass = 0;  /* don't print anything */
16771f5207b7SJohn Levon 	__inline_fn = call;
16781f5207b7SJohn Levon 	orig_budget = inline_budget;
16791f5207b7SJohn Levon 	inline_budget = inline_budget - 5;
16801f5207b7SJohn Levon 
16811f5207b7SJohn Levon 	base_type = get_base_type(call->fn->symbol);
16821f5207b7SJohn Levon 	cur_func_sym = call->fn->symbol;
16831f5207b7SJohn Levon 	if (call->fn->symbol->ident)
16841f5207b7SJohn Levon 		cur_func = call->fn->symbol->ident->name;
16851f5207b7SJohn Levon 	else
16861f5207b7SJohn Levon 		cur_func = NULL;
16871f5207b7SJohn Levon 	set_position(call->fn->symbol->pos);
16881f5207b7SJohn Levon 
16891f5207b7SJohn Levon 	save_all_states();
16901f5207b7SJohn Levon 	big_statement_stack = NULL;
16911f5207b7SJohn Levon 	big_expression_stack = NULL;
16921f5207b7SJohn Levon 	big_condition_stack = NULL;
16931f5207b7SJohn Levon 	switch_expr_stack = NULL;
16941f5207b7SJohn Levon 
16951f5207b7SJohn Levon 	sm_debug("inline function:  %s\n", cur_func);
16961f5207b7SJohn Levon 	__unnullify_path();
16971f5207b7SJohn Levon 	loop_num = 0;
16981f5207b7SJohn Levon 	loop_count = 0;
16991f5207b7SJohn Levon 	start_function_definition(call->fn->symbol);
17001f5207b7SJohn Levon 	__split_stmt(base_type->stmt);
17011f5207b7SJohn Levon 	__split_stmt(base_type->inline_stmt);
17021f5207b7SJohn Levon 	__pass_to_client(call->fn->symbol, END_FUNC_HOOK);
17031f5207b7SJohn Levon 	__pass_to_client(call->fn->symbol, AFTER_FUNC_HOOK);
17041f5207b7SJohn Levon 
17051f5207b7SJohn Levon 	free_expression_stack(&switch_expr_stack);
17061f5207b7SJohn Levon 	__free_ptr_list((struct ptr_list **)&big_statement_stack);
17071f5207b7SJohn Levon 	nullify_path();
17081f5207b7SJohn Levon 	free_goto_stack();
17091f5207b7SJohn Levon 
17101f5207b7SJohn Levon 	restore_flow_state();
17111f5207b7SJohn Levon 	fn_start_time = time_backup;
17121f5207b7SJohn Levon 	cur_func = cur_func_bak;
17131f5207b7SJohn Levon 
17141f5207b7SJohn Levon 	restore_all_states();
17151f5207b7SJohn Levon 	set_position(call->pos);
17161f5207b7SJohn Levon 	__inline_fn = orig_inline;
17171f5207b7SJohn Levon 	inline_budget = orig_budget;
17181f5207b7SJohn Levon 	__pass_to_client(call, INLINE_FN_END);
17191f5207b7SJohn Levon }
17201f5207b7SJohn Levon 
17211f5207b7SJohn Levon static struct symbol_list *inlines_called;
add_inline_function(struct symbol * sym)17221f5207b7SJohn Levon static void add_inline_function(struct symbol *sym)
17231f5207b7SJohn Levon {
17241f5207b7SJohn Levon 	static struct symbol_list *already_added;
17251f5207b7SJohn Levon 	struct symbol *tmp;
17261f5207b7SJohn Levon 
17271f5207b7SJohn Levon 	FOR_EACH_PTR(already_added, tmp) {
17281f5207b7SJohn Levon 		if (tmp == sym)
17291f5207b7SJohn Levon 			return;
17301f5207b7SJohn Levon 	} END_FOR_EACH_PTR(tmp);
17311f5207b7SJohn Levon 
17321f5207b7SJohn Levon 	add_ptr_list(&already_added, sym);
17331f5207b7SJohn Levon 	add_ptr_list(&inlines_called, sym);
17341f5207b7SJohn Levon }
17351f5207b7SJohn Levon 
process_inlines(void)17361f5207b7SJohn Levon static void process_inlines(void)
17371f5207b7SJohn Levon {
17381f5207b7SJohn Levon 	struct symbol *tmp;
17391f5207b7SJohn Levon 
17401f5207b7SJohn Levon 	FOR_EACH_PTR(inlines_called, tmp) {
17411f5207b7SJohn Levon 		split_function(tmp);
17421f5207b7SJohn Levon 	} END_FOR_EACH_PTR(tmp);
17431f5207b7SJohn Levon 	free_ptr_list(&inlines_called);
17441f5207b7SJohn Levon }
17451f5207b7SJohn Levon 
get_last_scoped_symbol(struct symbol_list * big_list,int use_static)17461f5207b7SJohn Levon static struct symbol *get_last_scoped_symbol(struct symbol_list *big_list, int use_static)
17471f5207b7SJohn Levon {
17481f5207b7SJohn Levon 	struct symbol *sym;
17491f5207b7SJohn Levon 
17501f5207b7SJohn Levon 	FOR_EACH_PTR_REVERSE(big_list, sym) {
17511f5207b7SJohn Levon 		if (!sym->scope)
17521f5207b7SJohn Levon 			continue;
17531f5207b7SJohn Levon 		if (use_static && sym->ctype.modifiers & MOD_STATIC)
17541f5207b7SJohn Levon 			return sym;
17551f5207b7SJohn Levon 		if (!use_static && !(sym->ctype.modifiers & MOD_STATIC))
17561f5207b7SJohn Levon 			return sym;
17571f5207b7SJohn Levon 	} END_FOR_EACH_PTR_REVERSE(sym);
17581f5207b7SJohn Levon 
17591f5207b7SJohn Levon 	return NULL;
17601f5207b7SJohn Levon }
17611f5207b7SJohn Levon 
interesting_function(struct symbol * sym)17621f5207b7SJohn Levon static bool interesting_function(struct symbol *sym)
17631f5207b7SJohn Levon {
17641f5207b7SJohn Levon 	static int prev_stream = -1;
17651f5207b7SJohn Levon 	static bool prev_answer;
17661f5207b7SJohn Levon 	const char *filename;
17671f5207b7SJohn Levon 	int len;
17681f5207b7SJohn Levon 
17691f5207b7SJohn Levon 	if (!(sym->ctype.modifiers & MOD_INLINE))
17701f5207b7SJohn Levon 		return true;
17711f5207b7SJohn Levon 
17721f5207b7SJohn Levon 	if (sym->pos.stream == prev_stream)
17731f5207b7SJohn Levon 		return prev_answer;
17741f5207b7SJohn Levon 
17751f5207b7SJohn Levon 	prev_stream = sym->pos.stream;
17761f5207b7SJohn Levon 	prev_answer = false;
17771f5207b7SJohn Levon 
17781f5207b7SJohn Levon 	filename = stream_name(sym->pos.stream);
17791f5207b7SJohn Levon 	len = strlen(filename);
17801f5207b7SJohn Levon 	if (len > 0 && filename[len - 1] == 'c')
17811f5207b7SJohn Levon 		prev_answer = true;
17821f5207b7SJohn Levon 	return prev_answer;
17831f5207b7SJohn Levon }
17841f5207b7SJohn Levon 
split_inlines_in_scope(struct symbol * sym)17851f5207b7SJohn Levon static void split_inlines_in_scope(struct symbol *sym)
17861f5207b7SJohn Levon {
17871f5207b7SJohn Levon 	struct symbol *base;
17881f5207b7SJohn Levon 	struct symbol_list *scope_list;
17891f5207b7SJohn Levon 	int stream;
17901f5207b7SJohn Levon 
17911f5207b7SJohn Levon 	scope_list = sym->scope->symbols;
17921f5207b7SJohn Levon 	stream = sym->pos.stream;
17931f5207b7SJohn Levon 
17941f5207b7SJohn Levon 	/* find the last static symbol in the file */
17951f5207b7SJohn Levon 	FOR_EACH_PTR_REVERSE(scope_list, sym) {
17961f5207b7SJohn Levon 		if (sym->pos.stream != stream)
17971f5207b7SJohn Levon 			continue;
17981f5207b7SJohn Levon 		if (sym->type != SYM_NODE)
17991f5207b7SJohn Levon 			continue;
18001f5207b7SJohn Levon 		base = get_base_type(sym);
18011f5207b7SJohn Levon 		if (!base)
18021f5207b7SJohn Levon 			continue;
18031f5207b7SJohn Levon 		if (base->type != SYM_FN)
18041f5207b7SJohn Levon 			continue;
18051f5207b7SJohn Levon 		if (!base->inline_stmt)
18061f5207b7SJohn Levon 			continue;
18071f5207b7SJohn Levon 		if (!interesting_function(sym))
18081f5207b7SJohn Levon 			continue;
18091f5207b7SJohn Levon 		add_inline_function(sym);
18101f5207b7SJohn Levon 	} END_FOR_EACH_PTR_REVERSE(sym);
18111f5207b7SJohn Levon 
18121f5207b7SJohn Levon 	process_inlines();
18131f5207b7SJohn Levon }
18141f5207b7SJohn Levon 
split_inlines(struct symbol_list * sym_list)18151f5207b7SJohn Levon static void split_inlines(struct symbol_list *sym_list)
18161f5207b7SJohn Levon {
18171f5207b7SJohn Levon 	struct symbol *sym;
18181f5207b7SJohn Levon 
18191f5207b7SJohn Levon 	sym = get_last_scoped_symbol(sym_list, 0);
18201f5207b7SJohn Levon 	if (sym)
18211f5207b7SJohn Levon 		split_inlines_in_scope(sym);
18221f5207b7SJohn Levon 	sym = get_last_scoped_symbol(sym_list, 1);
18231f5207b7SJohn Levon 	if (sym)
18241f5207b7SJohn Levon 		split_inlines_in_scope(sym);
18251f5207b7SJohn Levon }
18261f5207b7SJohn Levon 
clone_estates_perm(struct stree * orig)18271f5207b7SJohn Levon static struct stree *clone_estates_perm(struct stree *orig)
18281f5207b7SJohn Levon {
18291f5207b7SJohn Levon 	struct stree *ret = NULL;
18301f5207b7SJohn Levon 	struct sm_state *tmp;
18311f5207b7SJohn Levon 
18321f5207b7SJohn Levon 	FOR_EACH_SM(orig, tmp) {
18331f5207b7SJohn Levon 		set_state_stree_perm(&ret, tmp->owner, tmp->name, tmp->sym, clone_estate_perm(tmp->state));
18341f5207b7SJohn Levon 	} END_FOR_EACH_SM(tmp);
18351f5207b7SJohn Levon 
18361f5207b7SJohn Levon 	return ret;
18371f5207b7SJohn Levon }
18381f5207b7SJohn Levon 
18391f5207b7SJohn Levon struct position last_pos;
split_c_file_functions(struct symbol_list * sym_list)18401f5207b7SJohn Levon static void split_c_file_functions(struct symbol_list *sym_list)
18411f5207b7SJohn Levon {
18421f5207b7SJohn Levon 	struct symbol *sym;
18431f5207b7SJohn Levon 
18441f5207b7SJohn Levon 	__unnullify_path();
18451f5207b7SJohn Levon 	FOR_EACH_PTR(sym_list, sym) {
18461f5207b7SJohn Levon 		set_position(sym->pos);
18471f5207b7SJohn Levon 		if (sym->type != SYM_NODE || get_base_type(sym)->type != SYM_FN) {
18481f5207b7SJohn Levon 			__pass_to_client(sym, BASE_HOOK);
18491f5207b7SJohn Levon 			fake_global_assign(sym);
18501f5207b7SJohn Levon 		}
18511f5207b7SJohn Levon 	} END_FOR_EACH_PTR(sym);
18521f5207b7SJohn Levon 	global_states = clone_estates_perm(get_all_states_stree(SMATCH_EXTRA));
18531f5207b7SJohn Levon 	nullify_path();
18541f5207b7SJohn Levon 
18551f5207b7SJohn Levon 	FOR_EACH_PTR(sym_list, sym) {
18561f5207b7SJohn Levon 		set_position(sym->pos);
18571f5207b7SJohn Levon 		last_pos = sym->pos;
18581f5207b7SJohn Levon 		if (!interesting_function(sym))
18591f5207b7SJohn Levon 			continue;
18601f5207b7SJohn Levon 		if (sym->type == SYM_NODE && get_base_type(sym)->type == SYM_FN) {
18611f5207b7SJohn Levon 			split_function(sym);
18621f5207b7SJohn Levon 			process_inlines();
18631f5207b7SJohn Levon 		}
18641f5207b7SJohn Levon 		last_pos = sym->pos;
18651f5207b7SJohn Levon 	} END_FOR_EACH_PTR(sym);
18661f5207b7SJohn Levon 	split_inlines(sym_list);
18671f5207b7SJohn Levon 	__pass_to_client(sym_list, END_FILE_HOOK);
18681f5207b7SJohn Levon }
18691f5207b7SJohn Levon 
18701f5207b7SJohn Levon static int final_before_fake;
init_fake_env(void)18711f5207b7SJohn Levon void init_fake_env(void)
18721f5207b7SJohn Levon {
18731f5207b7SJohn Levon 	if (!in_fake_env)
18741f5207b7SJohn Levon 		final_before_fake = final_pass;
18751f5207b7SJohn Levon 	in_fake_env++;
18761f5207b7SJohn Levon 	__push_fake_cur_stree();
18771f5207b7SJohn Levon 	final_pass = 0;
18781f5207b7SJohn Levon }
18791f5207b7SJohn Levon 
end_fake_env(void)18801f5207b7SJohn Levon void end_fake_env(void)
18811f5207b7SJohn Levon {
18821f5207b7SJohn Levon 	__pop_fake_cur_stree();
18831f5207b7SJohn Levon 	in_fake_env--;
18841f5207b7SJohn Levon 	if (!in_fake_env)
18851f5207b7SJohn Levon 		final_pass = final_before_fake;
18861f5207b7SJohn Levon }
18871f5207b7SJohn Levon 
open_output_files(char * base_file)18881f5207b7SJohn Levon static void open_output_files(char *base_file)
18891f5207b7SJohn Levon {
18901f5207b7SJohn Levon 	char buf[256];
18911f5207b7SJohn Levon 
18921f5207b7SJohn Levon 	snprintf(buf, sizeof(buf), "%s.smatch", base_file);
18931f5207b7SJohn Levon 	sm_outfd = fopen(buf, "w");
18941f5207b7SJohn Levon 	if (!sm_outfd)
18951f5207b7SJohn Levon 		sm_fatal("Cannot open %s", buf);
18961f5207b7SJohn Levon 
18971f5207b7SJohn Levon 	if (!option_info)
18981f5207b7SJohn Levon 		return;
18991f5207b7SJohn Levon 
19001f5207b7SJohn Levon 	snprintf(buf, sizeof(buf), "%s.smatch.sql", base_file);
19011f5207b7SJohn Levon 	sql_outfd = fopen(buf, "w");
19021f5207b7SJohn Levon 	if (!sql_outfd)
19031f5207b7SJohn Levon 		sm_fatal("Error:  Cannot open %s", buf);
19041f5207b7SJohn Levon 
19051f5207b7SJohn Levon 	snprintf(buf, sizeof(buf), "%s.smatch.caller_info", base_file);
19061f5207b7SJohn Levon 	caller_info_fd = fopen(buf, "w");
19071f5207b7SJohn Levon 	if (!caller_info_fd)
19081f5207b7SJohn Levon 		sm_fatal("Error:  Cannot open %s", buf);
19091f5207b7SJohn Levon }
19101f5207b7SJohn Levon 
smatch(struct string_list * filelist)1911efe51d0cSJohn Levon void smatch(struct string_list *filelist)
19121f5207b7SJohn Levon {
19131f5207b7SJohn Levon 	struct symbol_list *sym_list;
19141f5207b7SJohn Levon 	struct timeval stop, start;
19151f5207b7SJohn Levon 	char *path;
19161f5207b7SJohn Levon 	int len;
19171f5207b7SJohn Levon 
19181f5207b7SJohn Levon 	gettimeofday(&start, NULL);
19191f5207b7SJohn Levon 
19201f5207b7SJohn Levon 	FOR_EACH_PTR_NOTAG(filelist, base_file) {
19211f5207b7SJohn Levon 		path = getcwd(NULL, 0);
19221f5207b7SJohn Levon 		free(full_base_file);
19231f5207b7SJohn Levon 		if (path) {
19241f5207b7SJohn Levon 			len = strlen(path) + 1 + strlen(base_file) + 1;
19251f5207b7SJohn Levon 			full_base_file = malloc(len);
19261f5207b7SJohn Levon 			snprintf(full_base_file, len, "%s/%s", path, base_file);
19271f5207b7SJohn Levon 		} else {
19281f5207b7SJohn Levon 			full_base_file = alloc_string(base_file);
19291f5207b7SJohn Levon 		}
19301f5207b7SJohn Levon 		if (option_file_output)
19311f5207b7SJohn Levon 			open_output_files(base_file);
19321f5207b7SJohn Levon 		sym_list = sparse_keep_tokens(base_file);
19331f5207b7SJohn Levon 		split_c_file_functions(sym_list);
19341f5207b7SJohn Levon 	} END_FOR_EACH_PTR_NOTAG(base_file);
19351f5207b7SJohn Levon 
19361f5207b7SJohn Levon 	gettimeofday(&stop, NULL);
19371f5207b7SJohn Levon 
19381f5207b7SJohn Levon 	set_position(last_pos);
1939efe51d0cSJohn Levon 	final_pass = 1;
19401f5207b7SJohn Levon 	if (option_time)
19411f5207b7SJohn Levon 		sm_msg("time: %lu", stop.tv_sec - start.tv_sec);
19421f5207b7SJohn Levon 	if (option_mem)
19431f5207b7SJohn Levon 		sm_msg("mem: %luKb", get_max_memory());
19441f5207b7SJohn Levon }
1945