#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
#include "rtl.h"
#include "varray.h"
#include "tree-gimple.h"
#include "tree-inline.h"
#include "diagnostic.h"
#include "langhooks.h"
#include "langhooks-def.h"
#include "tree-flow.h"
#include "timevar.h"
#include "except.h"
#include "hashtab.h"
#include "flags.h"
#include "function.h"
#include "expr.h"
#include "toplev.h"
#include "tree-pass.h"
struct lower_data
{
tree block;
tree return_statements;
tree returns_to_strip;
bool calls_builtin_setjmp;
};
static void lower_stmt (tree_stmt_iterator *, struct lower_data *);
static void lower_bind_expr (tree_stmt_iterator *, struct lower_data *);
static void lower_cond_expr (tree_stmt_iterator *, struct lower_data *);
static void lower_return_expr (tree_stmt_iterator *, struct lower_data *);
static void lower_builtin_setjmp (tree_stmt_iterator *);
static unsigned int
lower_function_body (void)
{
struct lower_data data;
tree *body_p = &DECL_SAVED_TREE (current_function_decl);
tree bind = *body_p;
tree_stmt_iterator i;
tree t, x;
gcc_assert (TREE_CODE (bind) == BIND_EXPR);
memset (&data, 0, sizeof (data));
data.block = DECL_INITIAL (current_function_decl);
BLOCK_SUBBLOCKS (data.block) = NULL_TREE;
BLOCK_CHAIN (data.block) = NULL_TREE;
TREE_ASM_WRITTEN (data.block) = 1;
*body_p = alloc_stmt_list ();
i = tsi_start (*body_p);
tsi_link_after (&i, bind, TSI_NEW_STMT);
lower_bind_expr (&i, &data);
i = tsi_last (*body_p);
if (block_may_fallthru (*body_p)
&& (data.return_statements == NULL
|| TREE_OPERAND (TREE_VALUE (data.return_statements), 0) != NULL)
&& ! (cfun->iasm_asm_function))
{
x = build1 (RETURN_EXPR, void_type_node, NULL);
SET_EXPR_LOCATION (x, cfun->function_end_locus);
tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
}
for (t = data.return_statements ; t ; t = TREE_CHAIN (t))
{
x = build1 (LABEL_EXPR, void_type_node, TREE_PURPOSE (t));
tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
x = TREE_VALUE (t);
tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
}
for (t = data.returns_to_strip ; t ; t = TREE_CHAIN (t))
{
x = TREE_PURPOSE (t);
#ifdef USE_MAPPED_LOCATION
SET_EXPR_LOCATION (x, UNKNOWN_LOCATION);
#else
SET_EXPR_LOCUS (x, NULL);
#endif
}
if (data.calls_builtin_setjmp)
{
tree disp_label, disp_var, arg;
disp_label = create_artificial_label ();
DECL_NONLOCAL (disp_label) = 1;
current_function_has_nonlocal_label = 1;
x = build1 (LABEL_EXPR, void_type_node, disp_label);
tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
disp_var = create_tmp_var (ptr_type_node, "setjmpvar");
t = build_addr (disp_label, current_function_decl);
arg = tree_cons (NULL, t, NULL);
t = implicit_built_in_decls[BUILT_IN_SETJMP_DISPATCHER];
t = build_function_call_expr (t,arg);
x = build2 (MODIFY_EXPR, void_type_node, disp_var, t);
tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
x = build1 (GOTO_EXPR, void_type_node, disp_var);
tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
}
gcc_assert (data.block == DECL_INITIAL (current_function_decl));
BLOCK_SUBBLOCKS (data.block)
= blocks_nreverse (BLOCK_SUBBLOCKS (data.block));
clear_block_marks (data.block);
return 0;
}
struct tree_opt_pass pass_lower_cf =
{
"lower",
NULL,
lower_function_body,
NULL,
NULL,
0,
0,
PROP_gimple_any,
PROP_gimple_lcf,
0,
0,
TODO_dump_func,
0
};
static void
lower_stmt_body (tree expr, struct lower_data *data)
{
tree_stmt_iterator tsi;
for (tsi = tsi_start (expr); !tsi_end_p (tsi); )
lower_stmt (&tsi, data);
}
static void
lower_omp_directive (tree_stmt_iterator *tsi, struct lower_data *data)
{
tree stmt;
stmt = tsi_stmt (*tsi);
lower_stmt_body (OMP_BODY (stmt), data);
tsi_link_before (tsi, stmt, TSI_SAME_STMT);
tsi_link_before (tsi, OMP_BODY (stmt), TSI_SAME_STMT);
OMP_BODY (stmt) = NULL_TREE;
tsi_delink (tsi);
}
static void
lower_stmt (tree_stmt_iterator *tsi, struct lower_data *data)
{
tree stmt = tsi_stmt (*tsi);
if (EXPR_HAS_LOCATION (stmt) && data)
TREE_BLOCK (stmt) = data->block;
switch (TREE_CODE (stmt))
{
case BIND_EXPR:
lower_bind_expr (tsi, data);
return;
case COND_EXPR:
lower_cond_expr (tsi, data);
return;
case RETURN_EXPR:
lower_return_expr (tsi, data);
return;
case TRY_FINALLY_EXPR:
case TRY_CATCH_EXPR:
lower_stmt_body (TREE_OPERAND (stmt, 0), data);
lower_stmt_body (TREE_OPERAND (stmt, 1), data);
break;
case CATCH_EXPR:
lower_stmt_body (CATCH_BODY (stmt), data);
break;
case EH_FILTER_EXPR:
lower_stmt_body (EH_FILTER_FAILURE (stmt), data);
break;
case NOP_EXPR:
case ASM_EXPR:
case GOTO_EXPR:
case LABEL_EXPR:
case SWITCH_EXPR:
case OMP_SECTIONS:
case OMP_SECTION:
case OMP_SINGLE:
case OMP_MASTER:
case OMP_ORDERED:
case OMP_CRITICAL:
case OMP_RETURN:
case OMP_CONTINUE:
break;
case OMP_FOR:
{
tree init = OMP_FOR_INIT(stmt);
gcc_assert(TREE_CODE(init) == MODIFY_EXPR && "expected simple assignment");
TREE_BLOCK(init) = data->block;
}
break;
case MODIFY_EXPR:
if (TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR)
stmt = TREE_OPERAND (stmt, 1);
else
break;
case CALL_EXPR:
{
tree decl = get_callee_fndecl (stmt);
if (decl
&& DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
&& DECL_FUNCTION_CODE (decl) == BUILT_IN_SETJMP)
{
data->calls_builtin_setjmp = true;
lower_builtin_setjmp (tsi);
return;
}
}
break;
case OMP_PARALLEL:
lower_omp_directive (tsi, data);
return;
default:
gcc_unreachable ();
}
tsi_next (tsi);
}
static void
lower_bind_expr (tree_stmt_iterator *tsi, struct lower_data *data)
{
tree old_block = data->block;
tree stmt = tsi_stmt (*tsi);
tree new_block = BIND_EXPR_BLOCK (stmt);
if (new_block)
{
if (new_block == old_block)
{
gcc_assert (new_block == DECL_INITIAL (current_function_decl));
new_block = NULL;
}
else
{
gcc_assert (!TREE_ASM_WRITTEN (new_block));
TREE_ASM_WRITTEN (new_block) = 1;
BLOCK_CHAIN (new_block) = BLOCK_SUBBLOCKS (old_block);
BLOCK_SUBBLOCKS (old_block) = new_block;
BLOCK_SUBBLOCKS (new_block) = NULL_TREE;
BLOCK_SUPERCONTEXT (new_block) = old_block;
data->block = new_block;
}
}
record_vars (BIND_EXPR_VARS (stmt));
lower_stmt_body (BIND_EXPR_BODY (stmt), data);
if (new_block)
{
gcc_assert (data->block == new_block);
BLOCK_SUBBLOCKS (new_block)
= blocks_nreverse (BLOCK_SUBBLOCKS (new_block));
data->block = old_block;
}
tsi_link_before (tsi, BIND_EXPR_BODY (stmt), TSI_SAME_STMT);
tsi_delink (tsi);
}
static bool
try_catch_may_fallthru (tree stmt)
{
tree_stmt_iterator i;
if (block_may_fallthru (TREE_OPERAND (stmt, 0)))
return true;
i = tsi_start (TREE_OPERAND (stmt, 1));
switch (TREE_CODE (tsi_stmt (i)))
{
case CATCH_EXPR:
for (; !tsi_end_p (i); tsi_next (&i))
{
if (block_may_fallthru (CATCH_BODY (tsi_stmt (i))))
return true;
}
return false;
case EH_FILTER_EXPR:
return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i)));
default:
return false;
}
}
bool
block_may_fallthru (tree block)
{
tree stmt = expr_last (block);
switch (stmt ? TREE_CODE (stmt) : ERROR_MARK)
{
case GOTO_EXPR:
case RETURN_EXPR:
case RESX_EXPR:
return false;
case SWITCH_EXPR:
return SWITCH_LABELS (stmt) == NULL_TREE;
case COND_EXPR:
if (block_may_fallthru (COND_EXPR_THEN (stmt)))
return true;
return block_may_fallthru (COND_EXPR_ELSE (stmt));
case BIND_EXPR:
return block_may_fallthru (BIND_EXPR_BODY (stmt));
case TRY_CATCH_EXPR:
return try_catch_may_fallthru (stmt);
case TRY_FINALLY_EXPR:
return (block_may_fallthru (TREE_OPERAND (stmt, 0))
&& block_may_fallthru (TREE_OPERAND (stmt, 1)));
case MODIFY_EXPR:
if (TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR)
stmt = TREE_OPERAND (stmt, 1);
else
return true;
case CALL_EXPR:
return (call_expr_flags (stmt) & ECF_NORETURN) == 0;
case CLEANUP_POINT_EXPR:
return block_may_fallthru (TREE_OPERAND (stmt, 0));
default:
return true;
}
}
static void
lower_cond_expr (tree_stmt_iterator *tsi, struct lower_data *data)
{
tree stmt = tsi_stmt (*tsi);
bool then_is_goto, else_is_goto;
tree then_branch, else_branch;
tree then_goto, else_goto;
then_branch = COND_EXPR_THEN (stmt);
else_branch = COND_EXPR_ELSE (stmt);
lower_stmt_body (then_branch, data);
lower_stmt_body (else_branch, data);
then_goto = expr_only (then_branch);
then_is_goto = then_goto && simple_goto_p (then_goto);
else_goto = expr_only (else_branch);
else_is_goto = else_goto && simple_goto_p (else_goto);
if (!then_is_goto || !else_is_goto)
{
tree then_label, else_label, end_label, t;
then_label = NULL_TREE;
else_label = NULL_TREE;
end_label = NULL_TREE;
if (!then_is_goto)
{
t = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
if (TREE_SIDE_EFFECTS (then_branch))
then_label = t;
else
end_label = t;
then_goto = build_and_jump (&LABEL_EXPR_LABEL (t));
}
if (!else_is_goto)
{
t = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
if (TREE_SIDE_EFFECTS (else_branch))
else_label = t;
else
{
if (end_label)
{
tsi_delink (tsi);
return;
}
else
end_label = t;
}
else_goto = build_and_jump (&LABEL_EXPR_LABEL (t));
}
if (then_label)
{
bool may_fallthru = block_may_fallthru (then_branch);
tsi_link_after (tsi, then_label, TSI_CONTINUE_LINKING);
tsi_link_after (tsi, then_branch, TSI_CONTINUE_LINKING);
if (else_label && may_fallthru)
{
end_label = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
t = build_and_jump (&LABEL_EXPR_LABEL (end_label));
tsi_link_after (tsi, t, TSI_CONTINUE_LINKING);
}
}
if (else_label)
{
tsi_link_after (tsi, else_label, TSI_CONTINUE_LINKING);
tsi_link_after (tsi, else_branch, TSI_CONTINUE_LINKING);
}
if (end_label)
tsi_link_after (tsi, end_label, TSI_CONTINUE_LINKING);
}
COND_EXPR_THEN (stmt) = then_goto;
COND_EXPR_ELSE (stmt) = else_goto;
tsi_next (tsi);
}
static void
lower_return_expr (tree_stmt_iterator *tsi, struct lower_data *data)
{
tree stmt = tsi_stmt (*tsi);
tree value, t, label;
value = TREE_OPERAND (stmt, 0);
if (value && TREE_CODE (value) == MODIFY_EXPR)
value = TREE_OPERAND (value, 1);
for (t = data->return_statements; t ; t = TREE_CHAIN (t))
{
tree tvalue = TREE_OPERAND (TREE_VALUE (t), 0);
if (tvalue && TREE_CODE (tvalue) == MODIFY_EXPR)
tvalue = TREE_OPERAND (tvalue, 1);
if (value == tvalue)
{
label = TREE_PURPOSE (t);
data->returns_to_strip = tree_cons (stmt, NULL_TREE, data->returns_to_strip);
goto found;
}
}
label = create_artificial_label ();
data->return_statements = tree_cons (label, stmt, data->return_statements);
found:
t = build1 (GOTO_EXPR, void_type_node, label);
SET_EXPR_LOCUS (t, EXPR_LOCUS (stmt));
tsi_link_before (tsi, t, TSI_SAME_STMT);
tsi_delink (tsi);
}
static void
lower_builtin_setjmp (tree_stmt_iterator *tsi)
{
tree stmt = tsi_stmt (*tsi);
tree cont_label = create_artificial_label ();
tree next_label = create_artificial_label ();
tree dest, t, arg;
FORCED_LABEL (next_label) = 1;
if (TREE_CODE (stmt) == MODIFY_EXPR)
{
dest = TREE_OPERAND (stmt, 0);
stmt = TREE_OPERAND (stmt, 1);
}
else
dest = NULL_TREE;
t = build_addr (next_label, current_function_decl);
arg = tree_cons (NULL, t, NULL);
t = TREE_VALUE (TREE_OPERAND (stmt, 1));
arg = tree_cons (NULL, t, arg);
t = implicit_built_in_decls[BUILT_IN_SETJMP_SETUP];
t = build_function_call_expr (t, arg);
SET_EXPR_LOCUS (t, EXPR_LOCUS (stmt));
tsi_link_before (tsi, t, TSI_SAME_STMT);
if (dest)
{
t = build2 (MODIFY_EXPR, void_type_node, dest, integer_zero_node);
SET_EXPR_LOCUS (t, EXPR_LOCUS (stmt));
tsi_link_before (tsi, t, TSI_SAME_STMT);
}
t = build1 (GOTO_EXPR, void_type_node, cont_label);
tsi_link_before (tsi, t, TSI_SAME_STMT);
t = build1 (LABEL_EXPR, void_type_node, next_label);
tsi_link_before (tsi, t, TSI_SAME_STMT);
t = build_addr (next_label, current_function_decl);
arg = tree_cons (NULL, t, NULL);
t = implicit_built_in_decls[BUILT_IN_SETJMP_RECEIVER];
t = build_function_call_expr (t, arg);
SET_EXPR_LOCUS (t, EXPR_LOCUS (stmt));
tsi_link_before (tsi, t, TSI_SAME_STMT);
if (dest)
{
t = build2 (MODIFY_EXPR, void_type_node, dest, integer_one_node);
SET_EXPR_LOCUS (t, EXPR_LOCUS (stmt));
tsi_link_before (tsi, t, TSI_SAME_STMT);
}
t = build1 (LABEL_EXPR, void_type_node, cont_label);
tsi_link_before (tsi, t, TSI_SAME_STMT);
tsi_delink (tsi);
}
void
record_vars_into (tree vars, tree fn)
{
struct function *saved_cfun = cfun;
if (fn != current_function_decl)
cfun = DECL_STRUCT_FUNCTION (fn);
for (; vars; vars = TREE_CHAIN (vars))
{
tree var = vars;
if (TREE_CODE (var) != VAR_DECL)
continue;
if (DECL_EXTERNAL (var))
continue;
cfun->unexpanded_var_list = tree_cons (NULL_TREE, var,
cfun->unexpanded_var_list);
}
if (fn != current_function_decl)
cfun = saved_cfun;
}
void
record_vars (tree vars)
{
record_vars_into (vars, current_function_decl);
}
static void
mark_blocks_with_used_vars (tree block)
{
tree var;
tree subblock;
if (!TREE_USED (block))
{
for (var = BLOCK_VARS (block);
var;
var = TREE_CHAIN (var))
{
if (TREE_USED (var))
{
TREE_USED (block) = true;
break;
}
}
}
for (subblock = BLOCK_SUBBLOCKS (block);
subblock;
subblock = BLOCK_CHAIN (subblock))
mark_blocks_with_used_vars (subblock);
}
static unsigned int
mark_used_blocks (void)
{
mark_blocks_with_used_vars (DECL_INITIAL (current_function_decl));
return 0;
}
struct tree_opt_pass pass_mark_used_blocks =
{
"blocks",
NULL,
mark_used_blocks,
NULL,
NULL,
0,
0,
0,
0,
0,
0,
TODO_dump_func,
0
};