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)
{
/* The outermost block of the original function may not be the
outermost statement chain of the gimplified function. So we
may see the outermost block just inside the function. */
gcc_assert (new_block == DECL_INITIAL (current_function_decl));
new_block = NULL;
}
else
{
/* We do not expect to handle duplicate blocks. */
gcc_assert (!TREE_ASM_WRITTEN (new_block));
TREE_ASM_WRITTEN (new_block) = 1;
/* Block tree may get clobbered by inlining. Normally this would
be fixed in rest_of_decl_compilation using block notes, but
since we are not going to emit them, it is up to us. */
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;
}
/* The BIND_EXPR no longer carries any useful information -- kill it. */
tsi_link_before (tsi, BIND_EXPR_BODY (stmt), TSI_SAME_STMT);
tsi_delink (tsi);
}
tree
pop_stmt_list (tree t)
{
tree u = NULL_TREE;
/* Pop statement lists until we reach the target level. The extra
nestings will be due to outstanding cleanups. */
while (1)
{
u = stmt_list_stack->pop ();
if (!stmt_list_stack->is_empty ())
{
tree x = stmt_list_stack->last ();
STATEMENT_LIST_HAS_LABEL (x) |= STATEMENT_LIST_HAS_LABEL (u);
}
if (t == u)
break;
}
gcc_assert (u != NULL_TREE);
/* If the statement list is completely empty, just return it. This is
just as good small as build_empty_stmt, with the advantage that
statement lists are merged when they appended to one another. So
using the STATEMENT_LIST avoids pathological buildup of EMPTY_STMT_P
statements. */
if (TREE_SIDE_EFFECTS (t))
{
tree_stmt_iterator i = tsi_start (t);
/* If the statement list contained exactly one statement, then
extract it immediately. */
if (tsi_one_before_end_p (i))
{
u = tsi_stmt (i);
tsi_delink (&i);
free_stmt_list (t);
t = u;
}
}
return t;
}
static void
lower_return_expr (tree_stmt_iterator *tsi, struct lower_data *data)
{
tree stmt = tsi_stmt (*tsi);
tree value, t, label;
/* Extract the value being returned. */
value = TREE_OPERAND (stmt, 0);
if (value && TREE_CODE (value) == MODIFY_EXPR)
value = TREE_OPERAND (value, 1);
/* Match this up with an existing return statement that's been created. */
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);
goto found;
}
}
/* Not found. Create a new label and record the return statement. */
label = create_artificial_label ();
data->return_statements = tree_cons (label, stmt, data->return_statements);
/* Generate a goto statement and remove the return statement. */
found:
t = build (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_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;
/* Replace the cond_expr with explicit gotos. */
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
{
/* Both THEN and ELSE can be no-ops if one or both contained an
empty BIND_EXPR that was associated with the toplevel block
of an inlined function. In that case remove_useless_stmts
can't have cleaned things up for us; kill the whole
conditional now. */
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);
}
