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:
/* Easy cases. If the last statement of the block implies
control transfer, then we can't fall through. */
return false;
case SWITCH_EXPR:
/* If SWITCH_LABELS is set, this is lowered, and represents a
branch to a selected label and hence can not fall through.
Otherwise SWITCH_BODY is set, and the switch can fall
through. */
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:
/* The finally clause is always executed after the try clause,
so if it does not fall through, then the try-finally will not
fall through. Otherwise, if the try clause does not fall
through, then when the finally clause falls through it will
resume execution wherever the try clause was going. So the
whole try-finally will only fall through if both the try
clause and the finally clause fall through. */
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;
/* FALLTHRU */
case CALL_EXPR:
/* Functions that do not return do not fall through. */
return (call_expr_flags (stmt) & ECF_NORETURN) == 0;
default:
return true;
}
}
static bool
try_catch_may_fallthru (const_tree stmt)
{
tree_stmt_iterator i;
/* If the TRY block can fall through, the whole TRY_CATCH can
fall through. */
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:
/* We expect to see a sequence of CATCH_EXPR trees, each with a
catch expression and a body. The whole TRY_CATCH may fall
through iff any of the catch bodies falls through. */
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:
/* The exception filter expression only matters if there is an
exception. If the exception does not match EH_FILTER_TYPES,
we will execute EH_FILTER_FAILURE, and we will fall through
if that falls through. If the exception does match
EH_FILTER_TYPES, the stack unwinder will continue up the
stack, so we will not fall through. We don't know whether we
will throw an exception which matches EH_FILTER_TYPES or not,
so we just ignore EH_FILTER_TYPES and assume that we might
throw an exception which doesn't match. */
return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i)));
default:
/* This case represents statements to be executed when an
exception occurs. Those statements are implicitly followed
by a RESX statement to resume execution after the exception.
So in this case the TRY_CATCH never falls through. */
return false;
}
}
bool
cxx_block_may_fallthru (const_tree stmt)
{
switch (TREE_CODE (stmt))
{
case EXPR_STMT:
return block_may_fallthru (EXPR_STMT_EXPR (stmt));
case THROW_EXPR:
return false;
case SWITCH_STMT:
return (!SWITCH_STMT_ALL_CASES_P (stmt)
|| !SWITCH_STMT_NO_BREAK_P (stmt)
|| block_may_fallthru (SWITCH_STMT_BODY (stmt)));
default:
return true;
}
}
bool
cxx_block_may_fallthru (const_tree stmt)
{
switch (TREE_CODE (stmt))
{
case EXPR_STMT:
return block_may_fallthru (EXPR_STMT_EXPR (stmt));
case THROW_EXPR:
return false;
default:
return true;
}
}
static void
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);
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;
data.return_statements = NULL_TREE;
*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 the function falls off the end, we need a null return statement.
If we've already got one in the return_statements list, we don't
need to do anything special. Otherwise build one by hand. */
if (block_may_fallthru (*body_p)
&& (data.return_statements == NULL
|| TREE_OPERAND (TREE_VALUE (data.return_statements), 0) != NULL))
{
x = build (RETURN_EXPR, void_type_node, NULL);
SET_EXPR_LOCATION (x, cfun->function_end_locus);
tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
}
/* If we lowered any return statements, emit the representative
at the end of the function. */
for (t = data.return_statements ; t ; t = TREE_CHAIN (t))
{
x = build (LABEL_EXPR, void_type_node, TREE_PURPOSE (t));
tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
/* Remove the line number from the representative return statement.
It now fills in for many such returns. Failure to remove this
will result in incorrect results for coverage analysis. */
x = TREE_VALUE (t);
#ifdef USE_MAPPED_LOCATION
SET_EXPR_LOCATION (x, UNKNOWN_LOCATION);
#else
SET_EXPR_LOCUS (x, NULL);
#endif
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);
}
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);
}
