/* GIMPLE lowering pass. Converts High GIMPLE into Low GIMPLE.
- Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
- Free Software Foundation, Inc.
+ Copyright (C) 2003-2016 Free Software Foundation, Inc.
This file is part of GCC.
#include "config.h"
#include "system.h"
#include "coretypes.h"
-#include "tm.h"
+#include "backend.h"
#include "tree.h"
-#include "rtl.h"
-#include "varray.h"
#include "gimple.h"
-#include "tree-iterator.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"
+#include "fold-const.h"
+#include "tree-nested.h"
+#include "calls.h"
+#include "gimple-iterator.h"
+#include "gimple-low.h"
/* The differences between High GIMPLE and Low GIMPLE are the
following:
struct return_statements_t
{
tree label;
- gimple stmt;
+ greturn *stmt;
};
typedef struct return_statements_t return_statements_t;
-DEF_VEC_O(return_statements_t);
-DEF_VEC_ALLOC_O(return_statements_t,heap);
struct lower_data
{
/* A vector of label and return statements to be moved to the end
of the function. */
- VEC(return_statements_t,heap) *return_statements;
+ vec<return_statements_t> return_statements;
- /* True if the function calls __builtin_setjmp. */
- bool calls_builtin_setjmp;
+ /* True if the current statement cannot fall through. */
+ bool cannot_fallthru;
};
static void lower_stmt (gimple_stmt_iterator *, struct lower_data *);
static void lower_gimple_bind (gimple_stmt_iterator *, struct lower_data *);
+static void lower_try_catch (gimple_stmt_iterator *, struct lower_data *);
static void lower_gimple_return (gimple_stmt_iterator *, struct lower_data *);
static void lower_builtin_setjmp (gimple_stmt_iterator *);
+static void lower_builtin_posix_memalign (gimple_stmt_iterator *);
/* Lower the body of current_function_decl from High GIMPLE into Low
gimple_seq body = gimple_body (current_function_decl);
gimple_seq lowered_body;
gimple_stmt_iterator i;
- gimple bind;
- tree t;
- gimple x;
+ gimple *bind;
+ gimple *x;
/* The gimplifier should've left a body of exactly one statement,
namely a GIMPLE_BIND. */
BLOCK_SUBBLOCKS (data.block) = NULL_TREE;
BLOCK_CHAIN (data.block) = NULL_TREE;
TREE_ASM_WRITTEN (data.block) = 1;
- data.return_statements = VEC_alloc (return_statements_t, heap, 8);
+ data.return_statements.create (8);
bind = gimple_seq_first_stmt (body);
lowered_body = NULL;
i = gsi_start (lowered_body);
lower_gimple_bind (&i, &data);
- /* Once the old body has been lowered, replace it with the new
- lowered sequence. */
- gimple_set_body (current_function_decl, lowered_body);
-
i = gsi_last (lowered_body);
/* If the function falls off the end, we need a null return statement.
If we've already got one in the return_statements vector, we don't
need to do anything special. Otherwise build one by hand. */
- if (gimple_seq_may_fallthru (lowered_body)
- && (VEC_empty (return_statements_t, data.return_statements)
- || gimple_return_retval (VEC_last (return_statements_t,
- data.return_statements)->stmt) != NULL))
+ bool may_fallthru = gimple_seq_may_fallthru (lowered_body);
+ if (may_fallthru
+ && (data.return_statements.is_empty ()
+ || (gimple_return_retval (data.return_statements.last().stmt)
+ != NULL)))
{
x = gimple_build_return (NULL);
gimple_set_location (x, cfun->function_end_locus);
gimple_set_block (x, DECL_INITIAL (current_function_decl));
gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
+ may_fallthru = false;
}
/* If we lowered any return statements, emit the representative
at the end of the function. */
- while (!VEC_empty (return_statements_t, data.return_statements))
+ while (!data.return_statements.is_empty ())
{
- return_statements_t t;
-
- /* Unfortunately, we can't use VEC_pop because it returns void for
- objects. */
- t = *VEC_last (return_statements_t, data.return_statements);
- VEC_truncate (return_statements_t,
- data.return_statements,
- VEC_length (return_statements_t,
- data.return_statements) - 1);
-
+ return_statements_t t = data.return_statements.pop ();
x = gimple_build_label (t.label);
gsi_insert_after (&i, x, GSI_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. */
- gimple_set_location (t.stmt, UNKNOWN_LOCATION);
gsi_insert_after (&i, t.stmt, GSI_CONTINUE_LINKING);
+ if (may_fallthru)
+ {
+ /* Remove the line number from the representative return statement.
+ It now fills in for the fallthru too. Failure to remove this
+ will result in incorrect results for coverage analysis. */
+ gimple_set_location (t.stmt, UNKNOWN_LOCATION);
+ may_fallthru = false;
+ }
}
- /* If the function calls __builtin_setjmp, we need to emit the computed
- goto that will serve as the unique dispatcher for all the receivers. */
- if (data.calls_builtin_setjmp)
- {
- tree disp_label, disp_var, arg;
-
- /* Build 'DISP_LABEL:' and insert. */
- disp_label = create_artificial_label ();
- /* This mark will create forward edges from every call site. */
- DECL_NONLOCAL (disp_label) = 1;
- cfun->has_nonlocal_label = 1;
- x = gimple_build_label (disp_label);
- gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
-
- /* Build 'DISP_VAR = __builtin_setjmp_dispatcher (DISP_LABEL);'
- and insert. */
- disp_var = create_tmp_var (ptr_type_node, "setjmpvar");
- arg = build_addr (disp_label, current_function_decl);
- t = implicit_built_in_decls[BUILT_IN_SETJMP_DISPATCHER];
- x = gimple_build_call (t, 1, arg);
- gimple_call_set_lhs (x, disp_var);
-
- /* Build 'goto DISP_VAR;' and insert. */
- gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
- x = gimple_build_goto (disp_var);
- gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
- }
+ /* Once the old body has been lowered, replace it with the new
+ lowered sequence. */
+ gimple_set_body (current_function_decl, lowered_body);
gcc_assert (data.block == DECL_INITIAL (current_function_decl));
BLOCK_SUBBLOCKS (data.block)
= blocks_nreverse (BLOCK_SUBBLOCKS (data.block));
clear_block_marks (data.block);
- VEC_free(return_statements_t, heap, data.return_statements);
+ data.return_statements.release ();
return 0;
}
-struct gimple_opt_pass pass_lower_cf =
+namespace {
+
+const pass_data pass_data_lower_cf =
{
- {
- GIMPLE_PASS,
- "lower", /* name */
- NULL, /* gate */
- lower_function_body, /* execute */
- NULL, /* sub */
- NULL, /* next */
- 0, /* static_pass_number */
- 0, /* tv_id */
- PROP_gimple_any, /* properties_required */
- PROP_gimple_lcf, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- TODO_dump_func /* todo_flags_finish */
- }
+ GIMPLE_PASS, /* type */
+ "lower", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ TV_NONE, /* tv_id */
+ PROP_gimple_any, /* properties_required */
+ PROP_gimple_lcf, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0, /* todo_flags_finish */
};
+class pass_lower_cf : public gimple_opt_pass
+{
+public:
+ pass_lower_cf (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_lower_cf, ctxt)
+ {}
-/* Verify if the type of the argument matches that of the function
- declaration. If we cannot verify this or there is a mismatch,
- mark the call expression so it doesn't get inlined later. */
+ /* opt_pass methods: */
+ virtual unsigned int execute (function *) { return lower_function_body (); }
-static void
-check_call_args (gimple stmt)
+}; // class pass_lower_cf
+
+} // anon namespace
+
+gimple_opt_pass *
+make_pass_lower_cf (gcc::context *ctxt)
{
- tree fndecl, parms, p;
- unsigned int i, nargs;
-
- if (gimple_call_cannot_inline_p (stmt))
- return;
-
- nargs = gimple_call_num_args (stmt);
-
- /* Get argument types for verification. */
- fndecl = gimple_call_fndecl (stmt);
- parms = NULL_TREE;
- if (fndecl)
- parms = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
- else if (POINTER_TYPE_P (TREE_TYPE (gimple_call_fn (stmt))))
- parms = TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (gimple_call_fn (stmt))));
-
- /* Verify if the type of the argument matches that of the function
- declaration. If we cannot verify this or there is a mismatch,
- mark the call expression so it doesn't get inlined later. */
- if (fndecl && DECL_ARGUMENTS (fndecl))
- {
- for (i = 0, p = DECL_ARGUMENTS (fndecl);
- i < nargs;
- i++, p = TREE_CHAIN (p))
- {
- /* We cannot distinguish a varargs function from the case
- of excess parameters, still deferring the inlining decision
- to the callee is possible. */
- if (!p)
- break;
- if (p == error_mark_node
- || gimple_call_arg (stmt, i) == error_mark_node
- || !fold_convertible_p (DECL_ARG_TYPE (p),
- gimple_call_arg (stmt, i)))
- {
- gimple_call_set_cannot_inline (stmt, true);
- break;
- }
- }
- }
- else if (parms)
- {
- for (i = 0, p = parms; i < nargs; i++, p = TREE_CHAIN (p))
- {
- /* If this is a varargs function defer inlining decision
- to callee. */
- if (!p)
- break;
- if (TREE_VALUE (p) == error_mark_node
- || gimple_call_arg (stmt, i) == error_mark_node
- || TREE_CODE (TREE_VALUE (p)) == VOID_TYPE
- || !fold_convertible_p (TREE_VALUE (p),
- gimple_call_arg (stmt, i)))
- {
- gimple_call_set_cannot_inline (stmt, true);
- break;
- }
- }
- }
- else
- {
- if (nargs != 0)
- gimple_call_set_cannot_inline (stmt, true);
- }
+ return new pass_lower_cf (ctxt);
}
-
/* Lower sequence SEQ. Unlike gimplification the statements are not relowered
when they are changed -- if this has to be done, the lowering routine must
do it explicitly. DATA is passed through the recursion. */
static void
-lower_sequence (gimple_seq seq, struct lower_data *data)
+lower_sequence (gimple_seq *seq, struct lower_data *data)
{
gimple_stmt_iterator gsi;
- for (gsi = gsi_start (seq); !gsi_end_p (gsi); )
+ for (gsi = gsi_start (*seq); !gsi_end_p (gsi); )
lower_stmt (&gsi, data);
}
static void
lower_omp_directive (gimple_stmt_iterator *gsi, struct lower_data *data)
{
- gimple stmt;
-
+ gimple *stmt;
+
stmt = gsi_stmt (*gsi);
- lower_sequence (gimple_omp_body (stmt), data);
- gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
- gsi_insert_seq_before (gsi, gimple_omp_body (stmt), GSI_SAME_STMT);
+ lower_sequence (gimple_omp_body_ptr (stmt), data);
+ gsi_insert_seq_after (gsi, gimple_omp_body (stmt), GSI_CONTINUE_LINKING);
gimple_omp_set_body (stmt, NULL);
- gsi_remove (gsi, false);
+ gsi_next (gsi);
}
-/* Lower statement GSI. DATA is passed through the recursion. */
+/* Lower statement GSI. DATA is passed through the recursion. We try to
+ track the fallthruness of statements and get rid of unreachable return
+ statements in order to prevent the EH lowering pass from adding useless
+ edges that can cause bogus warnings to be issued later; this guess need
+ not be 100% accurate, simply be conservative and reset cannot_fallthru
+ to false if we don't know. */
static void
lower_stmt (gimple_stmt_iterator *gsi, struct lower_data *data)
{
- gimple stmt = gsi_stmt (*gsi);
+ gimple *stmt = gsi_stmt (*gsi);
gimple_set_block (stmt, data->block);
{
case GIMPLE_BIND:
lower_gimple_bind (gsi, data);
+ /* Propagate fallthruness. */
return;
case GIMPLE_COND:
- /* The gimplifier has already lowered this into gotos. */
- break;
+ case GIMPLE_GOTO:
+ case GIMPLE_SWITCH:
+ data->cannot_fallthru = true;
+ gsi_next (gsi);
+ return;
case GIMPLE_RETURN:
- lower_gimple_return (gsi, data);
+ if (data->cannot_fallthru)
+ {
+ gsi_remove (gsi, false);
+ /* Propagate fallthruness. */
+ }
+ else
+ {
+ lower_gimple_return (gsi, data);
+ data->cannot_fallthru = true;
+ }
return;
case GIMPLE_TRY:
- lower_sequence (gimple_try_eval (stmt), data);
- lower_sequence (gimple_try_cleanup (stmt), data);
- break;
-
- case GIMPLE_CATCH:
- lower_sequence (gimple_catch_handler (stmt), data);
- break;
+ if (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH)
+ lower_try_catch (gsi, data);
+ else
+ {
+ /* It must be a GIMPLE_TRY_FINALLY. */
+ bool cannot_fallthru;
+ lower_sequence (gimple_try_eval_ptr (stmt), data);
+ cannot_fallthru = data->cannot_fallthru;
+
+ /* 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. */
+ data->cannot_fallthru = false;
+ lower_sequence (gimple_try_cleanup_ptr (stmt), data);
+ data->cannot_fallthru |= cannot_fallthru;
+ gsi_next (gsi);
+ }
+ return;
- case GIMPLE_EH_FILTER:
- lower_sequence (gimple_eh_filter_failure (stmt), data);
+ case GIMPLE_EH_ELSE:
+ {
+ geh_else *eh_else_stmt = as_a <geh_else *> (stmt);
+ lower_sequence (gimple_eh_else_n_body_ptr (eh_else_stmt), data);
+ lower_sequence (gimple_eh_else_e_body_ptr (eh_else_stmt), data);
+ }
break;
case GIMPLE_NOP:
case GIMPLE_ASM:
case GIMPLE_ASSIGN:
- case GIMPLE_GOTO:
case GIMPLE_PREDICT:
case GIMPLE_LABEL:
- case GIMPLE_SWITCH:
- case GIMPLE_CHANGE_DYNAMIC_TYPE:
+ case GIMPLE_EH_MUST_NOT_THROW:
case GIMPLE_OMP_FOR:
case GIMPLE_OMP_SECTIONS:
case GIMPLE_OMP_SECTIONS_SWITCH:
case GIMPLE_OMP_SECTION:
case GIMPLE_OMP_SINGLE:
case GIMPLE_OMP_MASTER:
+ case GIMPLE_OMP_TASKGROUP:
case GIMPLE_OMP_ORDERED:
case GIMPLE_OMP_CRITICAL:
case GIMPLE_OMP_RETURN:
case GIMPLE_CALL:
{
tree decl = gimple_call_fndecl (stmt);
+ unsigned i;
+
+ for (i = 0; i < gimple_call_num_args (stmt); i++)
+ {
+ tree arg = gimple_call_arg (stmt, i);
+ if (EXPR_P (arg))
+ TREE_SET_BLOCK (arg, data->block);
+ }
if (decl
- && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
- && DECL_FUNCTION_CODE (decl) == BUILT_IN_SETJMP)
+ && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
{
- data->calls_builtin_setjmp = true;
- lower_builtin_setjmp (gsi);
+ if (DECL_FUNCTION_CODE (decl) == BUILT_IN_SETJMP)
+ {
+ lower_builtin_setjmp (gsi);
+ data->cannot_fallthru = false;
+ return;
+ }
+ else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_POSIX_MEMALIGN
+ && flag_tree_bit_ccp
+ && gimple_builtin_call_types_compatible_p (stmt, decl))
+ {
+ lower_builtin_posix_memalign (gsi);
+ return;
+ }
+ }
+
+ if (decl && (flags_from_decl_or_type (decl) & ECF_NORETURN))
+ {
+ data->cannot_fallthru = true;
+ gsi_next (gsi);
return;
}
- check_call_args (stmt);
}
break;
case GIMPLE_OMP_PARALLEL:
case GIMPLE_OMP_TASK:
+ case GIMPLE_OMP_TARGET:
+ case GIMPLE_OMP_TEAMS:
+ data->cannot_fallthru = false;
lower_omp_directive (gsi, data);
+ data->cannot_fallthru = false;
return;
+ case GIMPLE_TRANSACTION:
+ lower_sequence (gimple_transaction_body_ptr (
+ as_a <gtransaction *> (stmt)),
+ data);
+ break;
+
default:
gcc_unreachable ();
}
+ data->cannot_fallthru = false;
gsi_next (gsi);
}
lower_gimple_bind (gimple_stmt_iterator *gsi, struct lower_data *data)
{
tree old_block = data->block;
- gimple stmt = gsi_stmt (*gsi);
+ gbind *stmt = as_a <gbind *> (gsi_stmt (*gsi));
tree new_block = gimple_bind_block (stmt);
if (new_block)
}
record_vars (gimple_bind_vars (stmt));
- lower_sequence (gimple_bind_body (stmt), data);
+ lower_sequence (gimple_bind_body_ptr (stmt), data);
if (new_block)
{
gsi_remove (gsi, false);
}
-/* Try to determine whether a TRY_CATCH expression can fall through.
- This is a subroutine of block_may_fallthru. */
+/* Same as above, but for a GIMPLE_TRY_CATCH. */
-static bool
-try_catch_may_fallthru (const_tree stmt)
+static void
+lower_try_catch (gimple_stmt_iterator *gsi, struct lower_data *data)
{
- tree_stmt_iterator i;
+ bool cannot_fallthru;
+ gimple *stmt = gsi_stmt (*gsi);
+ gimple_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;
+ /* We don't handle GIMPLE_TRY_FINALLY. */
+ gcc_assert (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH);
+
+ lower_sequence (gimple_try_eval_ptr (stmt), data);
+ cannot_fallthru = data->cannot_fallthru;
- i = tsi_start (TREE_OPERAND (stmt, 1));
- switch (TREE_CODE (tsi_stmt (i)))
+ i = gsi_start (*gimple_try_cleanup_ptr (stmt));
+ switch (gimple_code (gsi_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
+ 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 (; !tsi_end_p (i); tsi_next (&i))
+ for (; !gsi_end_p (i); gsi_next (&i))
{
- if (block_may_fallthru (CATCH_BODY (tsi_stmt (i))))
- return true;
+ data->cannot_fallthru = false;
+ lower_sequence (gimple_catch_handler_ptr (
+ as_a <gcatch *> (gsi_stmt (i))),
+ data);
+ if (!data->cannot_fallthru)
+ cannot_fallthru = false;
}
- return false;
+ break;
- case EH_FILTER_EXPR:
+ 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
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)));
+ data->cannot_fallthru = false;
+ lower_sequence (gimple_eh_filter_failure_ptr (gsi_stmt (i)), data);
+ if (!data->cannot_fallthru)
+ cannot_fallthru = false;
+ break;
default:
/* This case represents statements to be executed when an
exception occurs. Those statements are implicitly followed
- by a RESX_EXPR to resume execution after the exception. So
- in this case the TRY_CATCH never falls through. */
- return false;
+ by a GIMPLE_RESX to resume execution after the exception. So
+ in this case the try/catch never falls through. */
+ data->cannot_fallthru = false;
+ lower_sequence (gimple_try_cleanup_ptr (stmt), data);
+ break;
}
+
+ data->cannot_fallthru = cannot_fallthru;
+ gsi_next (gsi);
}
-/* Same as above, but for a GIMPLE_TRY_CATCH. */
+/* Try to determine whether a TRY_CATCH expression can fall through.
+ This is a subroutine of gimple_stmt_may_fallthru. */
static bool
-gimple_try_catch_may_fallthru (gimple stmt)
+gimple_try_catch_may_fallthru (gtry *stmt)
{
gimple_stmt_iterator i;
if (gimple_seq_may_fallthru (gimple_try_eval (stmt)))
return true;
- i = gsi_start (gimple_try_cleanup (stmt));
+ i = gsi_start (*gimple_try_cleanup_ptr (stmt));
switch (gimple_code (gsi_stmt (i)))
{
case GIMPLE_CATCH:
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 (gsi_stmt (i))))
+ if (gimple_seq_may_fallthru (gimple_catch_handler (
+ as_a <gcatch *> (gsi_stmt (i)))))
return true;
}
return false;
}
-/* Try to determine if we can fall out of the bottom of BLOCK. This guess
- need not be 100% accurate; simply be conservative and return true if we
- don't know. This is used only to avoid stupidly generating extra code.
- If we're wrong, we'll just delete the extra code later. */
-
-bool
-block_may_fallthru (const_tree block)
-{
- /* This CONST_CAST is okay because expr_last returns its argument
- unmodified and we assign it to a const_tree. */
- const_tree stmt = expr_last (CONST_CAST_TREE(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;
-
- case CLEANUP_POINT_EXPR:
- return block_may_fallthru (TREE_OPERAND (stmt, 0));
-
- default:
- return true;
- }
-}
-
-
/* Try to determine if we can continue executing the statement
immediately following STMT. This guess need not be 100% accurate;
simply be conservative and return true if we don't know. This is
we'll just delete the extra code later. */
bool
-gimple_stmt_may_fallthru (gimple stmt)
+gimple_stmt_may_fallthru (gimple *stmt)
{
if (!stmt)
return true;
case GIMPLE_GOTO:
case GIMPLE_RETURN:
case GIMPLE_RESX:
- /* Easy cases. If the last statement of the seq implies
+ /* 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 not fall through. */
- return true;
+ /* 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
return false;
case GIMPLE_BIND:
- return gimple_seq_may_fallthru (gimple_bind_body (stmt));
+ return gimple_seq_may_fallthru (
+ gimple_bind_body (as_a <gbind *> (stmt)));
case GIMPLE_TRY:
if (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH)
- return gimple_try_catch_may_fallthru (stmt);
+ return gimple_try_catch_may_fallthru (as_a <gtry *> (stmt));
/* It must be a GIMPLE_TRY_FINALLY. */
return (gimple_seq_may_fallthru (gimple_try_eval (stmt))
&& gimple_seq_may_fallthru (gimple_try_cleanup (stmt)));
- case GIMPLE_ASSIGN:
- return true;
+ case GIMPLE_EH_ELSE:
+ {
+ geh_else *eh_else_stmt = as_a <geh_else *> (stmt);
+ return (gimple_seq_may_fallthru (gimple_eh_else_n_body (eh_else_stmt))
+ || gimple_seq_may_fallthru (gimple_eh_else_e_body (
+ eh_else_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 void
lower_gimple_return (gimple_stmt_iterator *gsi, struct lower_data *data)
{
- gimple stmt = gsi_stmt (*gsi);
- gimple t;
+ greturn *stmt = as_a <greturn *> (gsi_stmt (*gsi));
+ gimple *t;
int i;
return_statements_t tmp_rs;
/* Match this up with an existing return statement that's been created. */
- for (i = VEC_length (return_statements_t, data->return_statements) - 1;
+ for (i = data->return_statements.length () - 1;
i >= 0; i--)
{
- tmp_rs = *VEC_index (return_statements_t, data->return_statements, i);
+ tmp_rs = data->return_statements[i];
if (gimple_return_retval (stmt) == gimple_return_retval (tmp_rs.stmt))
- goto found;
+ {
+ /* 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. */
+ gimple_set_location (tmp_rs.stmt, UNKNOWN_LOCATION);
+
+ goto found;
+ }
}
/* Not found. Create a new label and record the return statement. */
- tmp_rs.label = create_artificial_label ();
+ tmp_rs.label = create_artificial_label (cfun->function_end_locus);
tmp_rs.stmt = stmt;
- VEC_safe_push (return_statements_t, heap, data->return_statements, &tmp_rs);
+ data->return_statements.safe_push (tmp_rs);
/* Generate a goto statement and remove the return statement. */
found:
+ /* When not optimizing, make sure user returns are preserved. */
+ if (!optimize && gimple_has_location (stmt))
+ DECL_ARTIFICIAL (tmp_rs.label) = 0;
t = gimple_build_goto (tmp_rs.label);
gimple_set_location (t, gimple_location (stmt));
gimple_set_block (t, gimple_block (stmt));
gsi_remove (gsi, false);
}
-/* Lower a __builtin_setjmp TSI.
+/* Lower a __builtin_setjmp GSI.
__builtin_setjmp is passed a pointer to an array of five words (not
all will be used on all machines). It operates similarly to the C
library function of the same name, but is more efficient.
- It is lowered into 3 other builtins, namely __builtin_setjmp_setup,
- __builtin_setjmp_dispatcher and __builtin_setjmp_receiver, but with
- __builtin_setjmp_dispatcher shared among all the instances; that's
- why it is only emitted at the end by lower_function_body.
+ It is lowered into 2 other builtins, namely __builtin_setjmp_setup,
+ __builtin_setjmp_receiver.
After full lowering, the body of the function should look like:
{
- void * setjmpvar.0;
int D.1844;
int D.2844;
<D3850>:;
return;
- <D3853>: [non-local];
- setjmpvar.0 = __builtin_setjmp_dispatcher (&<D3853>);
- goto setjmpvar.0;
}
- The dispatcher block will be both the unique destination of all the
- abnormal call edges and the unique source of all the abnormal edges
- to the receivers, thus keeping the complexity explosion localized. */
+ During cfg creation an extra per-function (or per-OpenMP region)
+ block with ABNORMAL_DISPATCHER internal call will be added, unique
+ destination of all the abnormal call edges and the unique source of
+ all the abnormal edges to the receivers, thus keeping the complexity
+ explosion localized. */
static void
lower_builtin_setjmp (gimple_stmt_iterator *gsi)
{
- gimple stmt = gsi_stmt (*gsi);
- tree cont_label = create_artificial_label ();
- tree next_label = create_artificial_label ();
+ gimple *stmt = gsi_stmt (*gsi);
+ location_t loc = gimple_location (stmt);
+ tree cont_label = create_artificial_label (loc);
+ tree next_label = create_artificial_label (loc);
tree dest, t, arg;
- gimple g;
+ gimple *g;
+
+ /* __builtin_setjmp_{setup,receiver} aren't ECF_RETURNS_TWICE and for RTL
+ these builtins are modelled as non-local label jumps to the label
+ that is passed to these two builtins, so pretend we have a non-local
+ label during GIMPLE passes too. See PR60003. */
+ cfun->has_nonlocal_label = 1;
/* NEXT_LABEL is the label __builtin_longjmp will jump to. Its address is
passed to both __builtin_setjmp_setup and __builtin_setjmp_receiver. */
dest = gimple_call_lhs (stmt);
/* Build '__builtin_setjmp_setup (BUF, NEXT_LABEL)' and insert. */
- arg = build_addr (next_label, current_function_decl);
- t = implicit_built_in_decls[BUILT_IN_SETJMP_SETUP];
+ arg = build_addr (next_label);
+ t = builtin_decl_implicit (BUILT_IN_SETJMP_SETUP);
g = gimple_build_call (t, 2, gimple_call_arg (stmt, 0), arg);
- gimple_set_location (g, gimple_location (stmt));
+ gimple_set_location (g, loc);
gimple_set_block (g, gimple_block (stmt));
gsi_insert_before (gsi, g, GSI_SAME_STMT);
/* Build 'DEST = 0' and insert. */
if (dest)
{
- g = gimple_build_assign (dest, fold_convert (TREE_TYPE (dest),
- integer_zero_node));
- gimple_set_location (g, gimple_location (stmt));
+ g = gimple_build_assign (dest, build_zero_cst (TREE_TYPE (dest)));
+ gimple_set_location (g, loc);
gimple_set_block (g, gimple_block (stmt));
gsi_insert_before (gsi, g, GSI_SAME_STMT);
}
/* Build 'goto CONT_LABEL' and insert. */
g = gimple_build_goto (cont_label);
- gsi_insert_before (gsi, g, TSI_SAME_STMT);
+ gsi_insert_before (gsi, g, GSI_SAME_STMT);
/* Build 'NEXT_LABEL:' and insert. */
g = gimple_build_label (next_label);
gsi_insert_before (gsi, g, GSI_SAME_STMT);
/* Build '__builtin_setjmp_receiver (NEXT_LABEL)' and insert. */
- arg = build_addr (next_label, current_function_decl);
- t = implicit_built_in_decls[BUILT_IN_SETJMP_RECEIVER];
+ arg = build_addr (next_label);
+ t = builtin_decl_implicit (BUILT_IN_SETJMP_RECEIVER);
g = gimple_build_call (t, 1, arg);
- gimple_set_location (g, gimple_location (stmt));
+ gimple_set_location (g, loc);
gimple_set_block (g, gimple_block (stmt));
gsi_insert_before (gsi, g, GSI_SAME_STMT);
/* Build 'DEST = 1' and insert. */
if (dest)
{
- g = gimple_build_assign (dest, fold_convert (TREE_TYPE (dest),
- integer_one_node));
- gimple_set_location (g, gimple_location (stmt));
+ g = gimple_build_assign (dest, fold_convert_loc (loc, TREE_TYPE (dest),
+ integer_one_node));
+ gimple_set_location (g, loc);
gimple_set_block (g, gimple_block (stmt));
gsi_insert_before (gsi, g, GSI_SAME_STMT);
}
/* Remove the call to __builtin_setjmp. */
gsi_remove (gsi, false);
}
+
+/* Lower calls to posix_memalign to
+ res = posix_memalign (ptr, align, size);
+ if (res == 0)
+ *ptr = __builtin_assume_aligned (*ptr, align);
+ or to
+ void *tem;
+ res = posix_memalign (&tem, align, size);
+ if (res == 0)
+ ptr = __builtin_assume_aligned (tem, align);
+ in case the first argument was &ptr. That way we can get at the
+ alignment of the heap pointer in CCP. */
+
+static void
+lower_builtin_posix_memalign (gimple_stmt_iterator *gsi)
+{
+ gimple *stmt, *call = gsi_stmt (*gsi);
+ tree pptr = gimple_call_arg (call, 0);
+ tree align = gimple_call_arg (call, 1);
+ tree res = gimple_call_lhs (call);
+ tree ptr = create_tmp_reg (ptr_type_node);
+ if (TREE_CODE (pptr) == ADDR_EXPR)
+ {
+ tree tem = create_tmp_var (ptr_type_node);
+ TREE_ADDRESSABLE (tem) = 1;
+ gimple_call_set_arg (call, 0, build_fold_addr_expr (tem));
+ stmt = gimple_build_assign (ptr, tem);
+ }
+ else
+ stmt = gimple_build_assign (ptr,
+ fold_build2 (MEM_REF, ptr_type_node, pptr,
+ build_int_cst (ptr_type_node, 0)));
+ if (res == NULL_TREE)
+ {
+ res = create_tmp_reg (integer_type_node);
+ gimple_call_set_lhs (call, res);
+ }
+ tree align_label = create_artificial_label (UNKNOWN_LOCATION);
+ tree noalign_label = create_artificial_label (UNKNOWN_LOCATION);
+ gimple *cond = gimple_build_cond (EQ_EXPR, res, integer_zero_node,
+ align_label, noalign_label);
+ gsi_insert_after (gsi, cond, GSI_NEW_STMT);
+ gsi_insert_after (gsi, gimple_build_label (align_label), GSI_NEW_STMT);
+ gsi_insert_after (gsi, stmt, GSI_NEW_STMT);
+ stmt = gimple_build_call (builtin_decl_implicit (BUILT_IN_ASSUME_ALIGNED),
+ 2, ptr, align);
+ gimple_call_set_lhs (stmt, ptr);
+ gsi_insert_after (gsi, stmt, GSI_NEW_STMT);
+ stmt = gimple_build_assign (fold_build2 (MEM_REF, ptr_type_node, pptr,
+ build_int_cst (ptr_type_node, 0)),
+ ptr);
+ gsi_insert_after (gsi, stmt, GSI_NEW_STMT);
+ gsi_insert_after (gsi, gimple_build_label (noalign_label), GSI_NEW_STMT);
+}
\f
/* Record the variables in VARS into function FN. */
void
record_vars_into (tree vars, tree fn)
{
- if (fn != current_function_decl)
- push_cfun (DECL_STRUCT_FUNCTION (fn));
-
- for (; vars; vars = TREE_CHAIN (vars))
+ for (; vars; vars = DECL_CHAIN (vars))
{
tree var = vars;
continue;
/* Record the variable. */
- cfun->local_decls = tree_cons (NULL_TREE, var,
- cfun->local_decls);
+ add_local_decl (DECL_STRUCT_FUNCTION (fn), var);
}
-
- if (fn != current_function_decl)
- pop_cfun ();
}
{
record_vars_into (vars, current_function_decl);
}
-
-
-/* Mark BLOCK used if it has a used variable in it, then recurse over its
- subblocks. */
-
-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);
-}
-
-/* Mark the used attribute on blocks correctly. */
-
-static unsigned int
-mark_used_blocks (void)
-{
- mark_blocks_with_used_vars (DECL_INITIAL (current_function_decl));
- return 0;
-}
-
-
-struct gimple_opt_pass pass_mark_used_blocks =
-{
- {
- GIMPLE_PASS,
- "blocks", /* name */
- NULL, /* gate */
- mark_used_blocks, /* execute */
- NULL, /* sub */
- NULL, /* next */
- 0, /* static_pass_number */
- 0, /* tv_id */
- 0, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- TODO_dump_func /* todo_flags_finish */
- }
-};