bool
gimple_stmt_may_fallthru (gimple stmt)
{
if (!stmt)
return true;
switch (gimple_code (stmt))
{
case GIMPLE_GOTO:
case GIMPLE_RETURN:
case GIMPLE_RESX:
/* Easy cases. If the last statement of the seq implies
control transfer, then we can't fall through. */
return false;
case GIMPLE_SWITCH:
/* Switch has already been lowered and represents a branch
to a selected label and hence can't fall through. */
return false;
case GIMPLE_COND:
/* GIMPLE_COND's are already lowered into a two-way branch. They
can't fall through. */
return false;
case GIMPLE_BIND:
return gimple_seq_may_fallthru (gimple_bind_body (stmt));
case GIMPLE_TRY:
if (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH)
return gimple_try_catch_may_fallthru (stmt);
/* It must be a GIMPLE_TRY_FINALLY. */
/* 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 (gimple_seq_may_fallthru (gimple_try_eval (stmt))
&& gimple_seq_may_fallthru (gimple_try_cleanup (stmt)));
case GIMPLE_EH_ELSE:
return (gimple_seq_may_fallthru (gimple_eh_else_n_body (stmt))
|| gimple_seq_may_fallthru (gimple_eh_else_e_body (stmt)));
case GIMPLE_CALL:
/* Functions that do not return do not fall through. */
return (gimple_call_flags (stmt) & ECF_NORETURN) == 0;
default:
return true;
}
}
static bool
gimple_try_catch_may_fallthru (gtry *stmt)
{
gimple_stmt_iterator i;
/* We don't handle GIMPLE_TRY_FINALLY. */
gcc_assert (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH);
/* If the TRY block can fall through, the whole TRY_CATCH can
fall through. */
if (gimple_seq_may_fallthru (gimple_try_eval (stmt)))
return true;
i = gsi_start (*gimple_try_cleanup_ptr (stmt));
switch (gimple_code (gsi_stmt (i)))
{
case GIMPLE_CATCH:
/* We expect to see a sequence of GIMPLE_CATCH stmts, each with a
catch expression and a body. The whole try/catch may fall
through iff any of the catch bodies falls through. */
for (; !gsi_end_p (i); gsi_next (&i))
{
if (gimple_seq_may_fallthru (gimple_catch_handler (
as_a <gcatch *> (gsi_stmt (i)))))
return true;
}
return false;
case GIMPLE_EH_FILTER:
/* 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 gimple_seq_may_fallthru (gimple_eh_filter_failure (gsi_stmt (i)));
default:
/* This case represents statements to be executed when an
exception occurs. Those statements are implicitly followed
by a GIMPLE_RESX to resume execution after the exception. So
in this case the try/catch never falls through. */
return false;
}
}
