/* GIMPLE lowering pass. Converts High GIMPLE into Low GIMPLE.
|
/* GIMPLE lowering pass. Converts High GIMPLE into Low GIMPLE.
|
|
|
Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
|
Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
GCC is free software; you can redistribute it and/or modify it under
|
the terms of the GNU General Public License as published by the Free
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "varray.h"
|
#include "varray.h"
|
#include "gimple.h"
|
#include "gimple.h"
|
#include "tree-iterator.h"
|
#include "tree-iterator.h"
|
#include "tree-inline.h"
|
#include "tree-inline.h"
|
#include "diagnostic.h"
|
#include "diagnostic.h"
|
#include "langhooks.h"
|
#include "langhooks.h"
|
#include "langhooks-def.h"
|
#include "langhooks-def.h"
|
#include "tree-flow.h"
|
#include "tree-flow.h"
|
#include "timevar.h"
|
#include "timevar.h"
|
#include "except.h"
|
#include "except.h"
|
#include "hashtab.h"
|
#include "hashtab.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "function.h"
|
#include "function.h"
|
#include "expr.h"
|
#include "expr.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "tree-pass.h"
|
#include "tree-pass.h"
|
|
|
/* The differences between High GIMPLE and Low GIMPLE are the
|
/* The differences between High GIMPLE and Low GIMPLE are the
|
following:
|
following:
|
|
|
1- Lexical scopes are removed (i.e., GIMPLE_BIND disappears).
|
1- Lexical scopes are removed (i.e., GIMPLE_BIND disappears).
|
|
|
2- GIMPLE_TRY and GIMPLE_CATCH are converted to abnormal control
|
2- GIMPLE_TRY and GIMPLE_CATCH are converted to abnormal control
|
flow and exception regions are built as an on-the-side region
|
flow and exception regions are built as an on-the-side region
|
hierarchy (See tree-eh.c:lower_eh_constructs).
|
hierarchy (See tree-eh.c:lower_eh_constructs).
|
|
|
3- Multiple identical return statements are grouped into a single
|
3- Multiple identical return statements are grouped into a single
|
return and gotos to the unique return site. */
|
return and gotos to the unique return site. */
|
|
|
/* Match a return statement with a label. During lowering, we identify
|
/* Match a return statement with a label. During lowering, we identify
|
identical return statements and replace duplicates with a jump to
|
identical return statements and replace duplicates with a jump to
|
the corresponding label. */
|
the corresponding label. */
|
struct return_statements_t
|
struct return_statements_t
|
{
|
{
|
tree label;
|
tree label;
|
gimple stmt;
|
gimple stmt;
|
};
|
};
|
typedef struct return_statements_t return_statements_t;
|
typedef struct return_statements_t return_statements_t;
|
|
|
DEF_VEC_O(return_statements_t);
|
DEF_VEC_O(return_statements_t);
|
DEF_VEC_ALLOC_O(return_statements_t,heap);
|
DEF_VEC_ALLOC_O(return_statements_t,heap);
|
|
|
struct lower_data
|
struct lower_data
|
{
|
{
|
/* Block the current statement belongs to. */
|
/* Block the current statement belongs to. */
|
tree block;
|
tree block;
|
|
|
/* A vector of label and return statements to be moved to the end
|
/* A vector of label and return statements to be moved to the end
|
of the function. */
|
of the function. */
|
VEC(return_statements_t,heap) *return_statements;
|
VEC(return_statements_t,heap) *return_statements;
|
|
|
/* True if the current statement cannot fall through. */
|
/* True if the current statement cannot fall through. */
|
bool cannot_fallthru;
|
bool cannot_fallthru;
|
|
|
/* True if the function calls __builtin_setjmp. */
|
/* True if the function calls __builtin_setjmp. */
|
bool calls_builtin_setjmp;
|
bool calls_builtin_setjmp;
|
};
|
};
|
|
|
static void lower_stmt (gimple_stmt_iterator *, struct lower_data *);
|
static void lower_stmt (gimple_stmt_iterator *, struct lower_data *);
|
static void lower_gimple_bind (gimple_stmt_iterator *, struct lower_data *);
|
static void lower_gimple_bind (gimple_stmt_iterator *, struct lower_data *);
|
static void lower_gimple_return (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_setjmp (gimple_stmt_iterator *);
|
|
|
|
|
/* Lower the body of current_function_decl from High GIMPLE into Low
|
/* Lower the body of current_function_decl from High GIMPLE into Low
|
GIMPLE. */
|
GIMPLE. */
|
|
|
static unsigned int
|
static unsigned int
|
lower_function_body (void)
|
lower_function_body (void)
|
{
|
{
|
struct lower_data data;
|
struct lower_data data;
|
gimple_seq body = gimple_body (current_function_decl);
|
gimple_seq body = gimple_body (current_function_decl);
|
gimple_seq lowered_body;
|
gimple_seq lowered_body;
|
gimple_stmt_iterator i;
|
gimple_stmt_iterator i;
|
gimple bind;
|
gimple bind;
|
tree t;
|
tree t;
|
gimple x;
|
gimple x;
|
|
|
/* The gimplifier should've left a body of exactly one statement,
|
/* The gimplifier should've left a body of exactly one statement,
|
namely a GIMPLE_BIND. */
|
namely a GIMPLE_BIND. */
|
gcc_assert (gimple_seq_first (body) == gimple_seq_last (body)
|
gcc_assert (gimple_seq_first (body) == gimple_seq_last (body)
|
&& gimple_code (gimple_seq_first_stmt (body)) == GIMPLE_BIND);
|
&& gimple_code (gimple_seq_first_stmt (body)) == GIMPLE_BIND);
|
|
|
memset (&data, 0, sizeof (data));
|
memset (&data, 0, sizeof (data));
|
data.block = DECL_INITIAL (current_function_decl);
|
data.block = DECL_INITIAL (current_function_decl);
|
BLOCK_SUBBLOCKS (data.block) = NULL_TREE;
|
BLOCK_SUBBLOCKS (data.block) = NULL_TREE;
|
BLOCK_CHAIN (data.block) = NULL_TREE;
|
BLOCK_CHAIN (data.block) = NULL_TREE;
|
TREE_ASM_WRITTEN (data.block) = 1;
|
TREE_ASM_WRITTEN (data.block) = 1;
|
data.return_statements = VEC_alloc (return_statements_t, heap, 8);
|
data.return_statements = VEC_alloc (return_statements_t, heap, 8);
|
|
|
bind = gimple_seq_first_stmt (body);
|
bind = gimple_seq_first_stmt (body);
|
lowered_body = NULL;
|
lowered_body = NULL;
|
gimple_seq_add_stmt (&lowered_body, bind);
|
gimple_seq_add_stmt (&lowered_body, bind);
|
i = gsi_start (lowered_body);
|
i = gsi_start (lowered_body);
|
lower_gimple_bind (&i, &data);
|
lower_gimple_bind (&i, &data);
|
|
|
/* Once the old body has been lowered, replace it with the new
|
/* Once the old body has been lowered, replace it with the new
|
lowered sequence. */
|
lowered sequence. */
|
gimple_set_body (current_function_decl, lowered_body);
|
gimple_set_body (current_function_decl, lowered_body);
|
|
|
i = gsi_last (lowered_body);
|
i = gsi_last (lowered_body);
|
|
|
/* If the function falls off the end, we need a null return statement.
|
/* 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
|
If we've already got one in the return_statements vector, we don't
|
need to do anything special. Otherwise build one by hand. */
|
need to do anything special. Otherwise build one by hand. */
|
if (gimple_seq_may_fallthru (lowered_body)
|
if (gimple_seq_may_fallthru (lowered_body)
|
&& (VEC_empty (return_statements_t, data.return_statements)
|
&& (VEC_empty (return_statements_t, data.return_statements)
|
|| gimple_return_retval (VEC_last (return_statements_t,
|
|| gimple_return_retval (VEC_last (return_statements_t,
|
data.return_statements)->stmt) != NULL))
|
data.return_statements)->stmt) != NULL))
|
{
|
{
|
x = gimple_build_return (NULL);
|
x = gimple_build_return (NULL);
|
gimple_set_location (x, cfun->function_end_locus);
|
gimple_set_location (x, cfun->function_end_locus);
|
gimple_set_block (x, DECL_INITIAL (current_function_decl));
|
gimple_set_block (x, DECL_INITIAL (current_function_decl));
|
gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
|
gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
|
}
|
}
|
|
|
/* If we lowered any return statements, emit the representative
|
/* If we lowered any return statements, emit the representative
|
at the end of the function. */
|
at the end of the function. */
|
while (!VEC_empty (return_statements_t, data.return_statements))
|
while (!VEC_empty (return_statements_t, data.return_statements))
|
{
|
{
|
return_statements_t t;
|
return_statements_t t;
|
|
|
/* Unfortunately, we can't use VEC_pop because it returns void for
|
/* Unfortunately, we can't use VEC_pop because it returns void for
|
objects. */
|
objects. */
|
t = *VEC_last (return_statements_t, data.return_statements);
|
t = *VEC_last (return_statements_t, data.return_statements);
|
VEC_truncate (return_statements_t,
|
VEC_truncate (return_statements_t,
|
data.return_statements,
|
data.return_statements,
|
VEC_length (return_statements_t,
|
VEC_length (return_statements_t,
|
data.return_statements) - 1);
|
data.return_statements) - 1);
|
|
|
x = gimple_build_label (t.label);
|
x = gimple_build_label (t.label);
|
gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
|
gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
|
|
|
/* Remove the line number from the representative return statement.
|
/* Remove the line number from the representative return statement.
|
It now fills in for many such returns. Failure to remove this
|
It now fills in for many such returns. Failure to remove this
|
will result in incorrect results for coverage analysis. */
|
will result in incorrect results for coverage analysis. */
|
gimple_set_location (t.stmt, UNKNOWN_LOCATION);
|
gimple_set_location (t.stmt, UNKNOWN_LOCATION);
|
gsi_insert_after (&i, t.stmt, GSI_CONTINUE_LINKING);
|
gsi_insert_after (&i, t.stmt, GSI_CONTINUE_LINKING);
|
}
|
}
|
|
|
/* If the function calls __builtin_setjmp, we need to emit the computed
|
/* If the function calls __builtin_setjmp, we need to emit the computed
|
goto that will serve as the unique dispatcher for all the receivers. */
|
goto that will serve as the unique dispatcher for all the receivers. */
|
if (data.calls_builtin_setjmp)
|
if (data.calls_builtin_setjmp)
|
{
|
{
|
tree disp_label, disp_var, arg;
|
tree disp_label, disp_var, arg;
|
|
|
/* Build 'DISP_LABEL:' and insert. */
|
/* Build 'DISP_LABEL:' and insert. */
|
disp_label = create_artificial_label (cfun->function_end_locus);
|
disp_label = create_artificial_label (cfun->function_end_locus);
|
/* This mark will create forward edges from every call site. */
|
/* This mark will create forward edges from every call site. */
|
DECL_NONLOCAL (disp_label) = 1;
|
DECL_NONLOCAL (disp_label) = 1;
|
cfun->has_nonlocal_label = 1;
|
cfun->has_nonlocal_label = 1;
|
x = gimple_build_label (disp_label);
|
x = gimple_build_label (disp_label);
|
gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
|
gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
|
|
|
/* Build 'DISP_VAR = __builtin_setjmp_dispatcher (DISP_LABEL);'
|
/* Build 'DISP_VAR = __builtin_setjmp_dispatcher (DISP_LABEL);'
|
and insert. */
|
and insert. */
|
disp_var = create_tmp_var (ptr_type_node, "setjmpvar");
|
disp_var = create_tmp_var (ptr_type_node, "setjmpvar");
|
arg = build_addr (disp_label, current_function_decl);
|
arg = build_addr (disp_label, current_function_decl);
|
t = implicit_built_in_decls[BUILT_IN_SETJMP_DISPATCHER];
|
t = implicit_built_in_decls[BUILT_IN_SETJMP_DISPATCHER];
|
x = gimple_build_call (t, 1, arg);
|
x = gimple_build_call (t, 1, arg);
|
gimple_call_set_lhs (x, disp_var);
|
gimple_call_set_lhs (x, disp_var);
|
|
|
/* Build 'goto DISP_VAR;' and insert. */
|
/* Build 'goto DISP_VAR;' and insert. */
|
gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
|
gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
|
x = gimple_build_goto (disp_var);
|
x = gimple_build_goto (disp_var);
|
gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
|
gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
|
}
|
}
|
|
|
gcc_assert (data.block == DECL_INITIAL (current_function_decl));
|
gcc_assert (data.block == DECL_INITIAL (current_function_decl));
|
BLOCK_SUBBLOCKS (data.block)
|
BLOCK_SUBBLOCKS (data.block)
|
= blocks_nreverse (BLOCK_SUBBLOCKS (data.block));
|
= blocks_nreverse (BLOCK_SUBBLOCKS (data.block));
|
|
|
clear_block_marks (data.block);
|
clear_block_marks (data.block);
|
VEC_free(return_statements_t, heap, data.return_statements);
|
VEC_free(return_statements_t, heap, data.return_statements);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
struct gimple_opt_pass pass_lower_cf =
|
struct gimple_opt_pass pass_lower_cf =
|
{
|
{
|
{
|
{
|
GIMPLE_PASS,
|
GIMPLE_PASS,
|
"lower", /* name */
|
"lower", /* name */
|
NULL, /* gate */
|
NULL, /* gate */
|
lower_function_body, /* execute */
|
lower_function_body, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_NONE, /* tv_id */
|
TV_NONE, /* tv_id */
|
PROP_gimple_any, /* properties_required */
|
PROP_gimple_any, /* properties_required */
|
PROP_gimple_lcf, /* properties_provided */
|
PROP_gimple_lcf, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
TODO_dump_func /* todo_flags_finish */
|
TODO_dump_func /* todo_flags_finish */
|
}
|
}
|
};
|
};
|
|
|
|
|
/* Verify if the type of the argument matches that of the function
|
/* Verify if the type of the argument matches that of the function
|
declaration. If we cannot verify this or there is a mismatch,
|
declaration. If we cannot verify this or there is a mismatch,
|
return false. */
|
return false. */
|
|
|
bool
|
bool
|
gimple_check_call_args (gimple stmt)
|
gimple_check_call_args (gimple stmt)
|
{
|
{
|
tree fndecl, parms, p;
|
tree fndecl, parms, p;
|
unsigned int i, nargs;
|
unsigned int i, nargs;
|
|
|
nargs = gimple_call_num_args (stmt);
|
nargs = gimple_call_num_args (stmt);
|
|
|
/* Get argument types for verification. */
|
/* Get argument types for verification. */
|
fndecl = gimple_call_fndecl (stmt);
|
fndecl = gimple_call_fndecl (stmt);
|
parms = NULL_TREE;
|
parms = NULL_TREE;
|
if (fndecl)
|
if (fndecl)
|
parms = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
|
parms = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
|
else if (POINTER_TYPE_P (TREE_TYPE (gimple_call_fn (stmt))))
|
else if (POINTER_TYPE_P (TREE_TYPE (gimple_call_fn (stmt))))
|
parms = TYPE_ARG_TYPES (TREE_TYPE (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
|
/* Verify if the type of the argument matches that of the function
|
declaration. If we cannot verify this or there is a mismatch,
|
declaration. If we cannot verify this or there is a mismatch,
|
return false. */
|
return false. */
|
if (fndecl && DECL_ARGUMENTS (fndecl))
|
if (fndecl && DECL_ARGUMENTS (fndecl))
|
{
|
{
|
for (i = 0, p = DECL_ARGUMENTS (fndecl);
|
for (i = 0, p = DECL_ARGUMENTS (fndecl);
|
i < nargs;
|
i < nargs;
|
i++, p = TREE_CHAIN (p))
|
i++, p = TREE_CHAIN (p))
|
{
|
{
|
/* We cannot distinguish a varargs function from the case
|
/* We cannot distinguish a varargs function from the case
|
of excess parameters, still deferring the inlining decision
|
of excess parameters, still deferring the inlining decision
|
to the callee is possible. */
|
to the callee is possible. */
|
if (!p)
|
if (!p)
|
break;
|
break;
|
if (p == error_mark_node
|
if (p == error_mark_node
|
|| gimple_call_arg (stmt, i) == error_mark_node
|
|| gimple_call_arg (stmt, i) == error_mark_node
|
|| !fold_convertible_p (DECL_ARG_TYPE (p),
|
|| !fold_convertible_p (DECL_ARG_TYPE (p),
|
gimple_call_arg (stmt, i)))
|
gimple_call_arg (stmt, i)))
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
else if (parms)
|
else if (parms)
|
{
|
{
|
for (i = 0, p = parms; i < nargs; i++, p = TREE_CHAIN (p))
|
for (i = 0, p = parms; i < nargs; i++, p = TREE_CHAIN (p))
|
{
|
{
|
/* If this is a varargs function defer inlining decision
|
/* If this is a varargs function defer inlining decision
|
to callee. */
|
to callee. */
|
if (!p)
|
if (!p)
|
break;
|
break;
|
if (TREE_VALUE (p) == error_mark_node
|
if (TREE_VALUE (p) == error_mark_node
|
|| gimple_call_arg (stmt, i) == error_mark_node
|
|| gimple_call_arg (stmt, i) == error_mark_node
|
|| TREE_CODE (TREE_VALUE (p)) == VOID_TYPE
|
|| TREE_CODE (TREE_VALUE (p)) == VOID_TYPE
|
|| !fold_convertible_p (TREE_VALUE (p),
|
|| !fold_convertible_p (TREE_VALUE (p),
|
gimple_call_arg (stmt, i)))
|
gimple_call_arg (stmt, i)))
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
if (nargs != 0)
|
if (nargs != 0)
|
return false;
|
return false;
|
}
|
}
|
return true;
|
return true;
|
}
|
}
|
|
|
|
|
/* Lower sequence SEQ. Unlike gimplification the statements are not relowered
|
/* Lower sequence SEQ. Unlike gimplification the statements are not relowered
|
when they are changed -- if this has to be done, the lowering routine must
|
when they are changed -- if this has to be done, the lowering routine must
|
do it explicitly. DATA is passed through the recursion. */
|
do it explicitly. DATA is passed through the recursion. */
|
|
|
static void
|
static void
|
lower_sequence (gimple_seq seq, struct lower_data *data)
|
lower_sequence (gimple_seq seq, struct lower_data *data)
|
{
|
{
|
gimple_stmt_iterator gsi;
|
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);
|
lower_stmt (&gsi, data);
|
}
|
}
|
|
|
|
|
/* Lower the OpenMP directive statement pointed by GSI. DATA is
|
/* Lower the OpenMP directive statement pointed by GSI. DATA is
|
passed through the recursion. */
|
passed through the recursion. */
|
|
|
static void
|
static void
|
lower_omp_directive (gimple_stmt_iterator *gsi, struct lower_data *data)
|
lower_omp_directive (gimple_stmt_iterator *gsi, struct lower_data *data)
|
{
|
{
|
gimple stmt;
|
gimple stmt;
|
|
|
stmt = gsi_stmt (*gsi);
|
stmt = gsi_stmt (*gsi);
|
|
|
lower_sequence (gimple_omp_body (stmt), data);
|
lower_sequence (gimple_omp_body (stmt), data);
|
gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
|
gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
|
gsi_insert_seq_before (gsi, gimple_omp_body (stmt), GSI_SAME_STMT);
|
gsi_insert_seq_before (gsi, gimple_omp_body (stmt), GSI_SAME_STMT);
|
gimple_omp_set_body (stmt, NULL);
|
gimple_omp_set_body (stmt, NULL);
|
gsi_remove (gsi, false);
|
gsi_remove (gsi, false);
|
}
|
}
|
|
|
|
|
/* Lower statement GSI. DATA is passed through the recursion. We try to
|
/* Lower statement GSI. DATA is passed through the recursion. We try to
|
track the fallthruness of statements and get rid of unreachable return
|
track the fallthruness of statements and get rid of unreachable return
|
statements in order to prevent the EH lowering pass from adding useless
|
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
|
edges that can cause bogus warnings to be issued later; this guess need
|
not be 100% accurate, simply be conservative and reset cannot_fallthru
|
not be 100% accurate, simply be conservative and reset cannot_fallthru
|
to false if we don't know. */
|
to false if we don't know. */
|
|
|
static void
|
static void
|
lower_stmt (gimple_stmt_iterator *gsi, struct lower_data *data)
|
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);
|
gimple_set_block (stmt, data->block);
|
|
|
switch (gimple_code (stmt))
|
switch (gimple_code (stmt))
|
{
|
{
|
case GIMPLE_BIND:
|
case GIMPLE_BIND:
|
lower_gimple_bind (gsi, data);
|
lower_gimple_bind (gsi, data);
|
/* Propagate fallthruness. */
|
/* Propagate fallthruness. */
|
return;
|
return;
|
|
|
case GIMPLE_COND:
|
case GIMPLE_COND:
|
case GIMPLE_GOTO:
|
case GIMPLE_GOTO:
|
case GIMPLE_SWITCH:
|
case GIMPLE_SWITCH:
|
data->cannot_fallthru = true;
|
data->cannot_fallthru = true;
|
gsi_next (gsi);
|
gsi_next (gsi);
|
return;
|
return;
|
|
|
case GIMPLE_RETURN:
|
case GIMPLE_RETURN:
|
if (data->cannot_fallthru)
|
if (data->cannot_fallthru)
|
{
|
{
|
gsi_remove (gsi, false);
|
gsi_remove (gsi, false);
|
/* Propagate fallthruness. */
|
/* Propagate fallthruness. */
|
}
|
}
|
else
|
else
|
{
|
{
|
lower_gimple_return (gsi, data);
|
lower_gimple_return (gsi, data);
|
data->cannot_fallthru = true;
|
data->cannot_fallthru = true;
|
}
|
}
|
return;
|
return;
|
|
|
case GIMPLE_TRY:
|
case GIMPLE_TRY:
|
{
|
{
|
bool try_cannot_fallthru;
|
bool try_cannot_fallthru;
|
lower_sequence (gimple_try_eval (stmt), data);
|
lower_sequence (gimple_try_eval (stmt), data);
|
try_cannot_fallthru = data->cannot_fallthru;
|
try_cannot_fallthru = data->cannot_fallthru;
|
data->cannot_fallthru = false;
|
data->cannot_fallthru = false;
|
lower_sequence (gimple_try_cleanup (stmt), data);
|
lower_sequence (gimple_try_cleanup (stmt), data);
|
/* See gimple_stmt_may_fallthru for the rationale. */
|
/* See gimple_stmt_may_fallthru for the rationale. */
|
if (gimple_try_kind (stmt) == GIMPLE_TRY_FINALLY)
|
if (gimple_try_kind (stmt) == GIMPLE_TRY_FINALLY)
|
{
|
{
|
data->cannot_fallthru |= try_cannot_fallthru;
|
data->cannot_fallthru |= try_cannot_fallthru;
|
gsi_next (gsi);
|
gsi_next (gsi);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
break;
|
break;
|
|
|
case GIMPLE_CATCH:
|
case GIMPLE_CATCH:
|
data->cannot_fallthru = false;
|
data->cannot_fallthru = false;
|
lower_sequence (gimple_catch_handler (stmt), data);
|
lower_sequence (gimple_catch_handler (stmt), data);
|
break;
|
break;
|
|
|
case GIMPLE_EH_FILTER:
|
case GIMPLE_EH_FILTER:
|
data->cannot_fallthru = false;
|
data->cannot_fallthru = false;
|
lower_sequence (gimple_eh_filter_failure (stmt), data);
|
lower_sequence (gimple_eh_filter_failure (stmt), data);
|
break;
|
break;
|
|
|
case GIMPLE_NOP:
|
case GIMPLE_NOP:
|
case GIMPLE_ASM:
|
case GIMPLE_ASM:
|
case GIMPLE_ASSIGN:
|
case GIMPLE_ASSIGN:
|
case GIMPLE_PREDICT:
|
case GIMPLE_PREDICT:
|
case GIMPLE_LABEL:
|
case GIMPLE_LABEL:
|
case GIMPLE_EH_MUST_NOT_THROW:
|
case GIMPLE_EH_MUST_NOT_THROW:
|
case GIMPLE_OMP_FOR:
|
case GIMPLE_OMP_FOR:
|
case GIMPLE_OMP_SECTIONS:
|
case GIMPLE_OMP_SECTIONS:
|
case GIMPLE_OMP_SECTIONS_SWITCH:
|
case GIMPLE_OMP_SECTIONS_SWITCH:
|
case GIMPLE_OMP_SECTION:
|
case GIMPLE_OMP_SECTION:
|
case GIMPLE_OMP_SINGLE:
|
case GIMPLE_OMP_SINGLE:
|
case GIMPLE_OMP_MASTER:
|
case GIMPLE_OMP_MASTER:
|
case GIMPLE_OMP_ORDERED:
|
case GIMPLE_OMP_ORDERED:
|
case GIMPLE_OMP_CRITICAL:
|
case GIMPLE_OMP_CRITICAL:
|
case GIMPLE_OMP_RETURN:
|
case GIMPLE_OMP_RETURN:
|
case GIMPLE_OMP_ATOMIC_LOAD:
|
case GIMPLE_OMP_ATOMIC_LOAD:
|
case GIMPLE_OMP_ATOMIC_STORE:
|
case GIMPLE_OMP_ATOMIC_STORE:
|
case GIMPLE_OMP_CONTINUE:
|
case GIMPLE_OMP_CONTINUE:
|
break;
|
break;
|
|
|
case GIMPLE_CALL:
|
case GIMPLE_CALL:
|
{
|
{
|
tree decl = gimple_call_fndecl (stmt);
|
tree decl = gimple_call_fndecl (stmt);
|
|
|
if (decl
|
if (decl
|
&& DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
|
&& DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
|
&& DECL_FUNCTION_CODE (decl) == BUILT_IN_SETJMP)
|
&& DECL_FUNCTION_CODE (decl) == BUILT_IN_SETJMP)
|
{
|
{
|
lower_builtin_setjmp (gsi);
|
lower_builtin_setjmp (gsi);
|
data->cannot_fallthru = false;
|
data->cannot_fallthru = false;
|
data->calls_builtin_setjmp = true;
|
data->calls_builtin_setjmp = true;
|
return;
|
return;
|
}
|
}
|
|
|
if (decl && (flags_from_decl_or_type (decl) & ECF_NORETURN))
|
if (decl && (flags_from_decl_or_type (decl) & ECF_NORETURN))
|
{
|
{
|
data->cannot_fallthru = true;
|
data->cannot_fallthru = true;
|
gsi_next (gsi);
|
gsi_next (gsi);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
break;
|
break;
|
|
|
case GIMPLE_OMP_PARALLEL:
|
case GIMPLE_OMP_PARALLEL:
|
case GIMPLE_OMP_TASK:
|
case GIMPLE_OMP_TASK:
|
data->cannot_fallthru = false;
|
data->cannot_fallthru = false;
|
lower_omp_directive (gsi, data);
|
lower_omp_directive (gsi, data);
|
data->cannot_fallthru = false;
|
data->cannot_fallthru = false;
|
return;
|
return;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
data->cannot_fallthru = false;
|
data->cannot_fallthru = false;
|
gsi_next (gsi);
|
gsi_next (gsi);
|
}
|
}
|
|
|
/* Lower a bind_expr TSI. DATA is passed through the recursion. */
|
/* Lower a bind_expr TSI. DATA is passed through the recursion. */
|
|
|
static void
|
static void
|
lower_gimple_bind (gimple_stmt_iterator *gsi, struct lower_data *data)
|
lower_gimple_bind (gimple_stmt_iterator *gsi, struct lower_data *data)
|
{
|
{
|
tree old_block = data->block;
|
tree old_block = data->block;
|
gimple stmt = gsi_stmt (*gsi);
|
gimple stmt = gsi_stmt (*gsi);
|
tree new_block = gimple_bind_block (stmt);
|
tree new_block = gimple_bind_block (stmt);
|
|
|
if (new_block)
|
if (new_block)
|
{
|
{
|
if (new_block == old_block)
|
if (new_block == old_block)
|
{
|
{
|
/* The outermost block of the original function may not be the
|
/* The outermost block of the original function may not be the
|
outermost statement chain of the gimplified function. So we
|
outermost statement chain of the gimplified function. So we
|
may see the outermost block just inside the function. */
|
may see the outermost block just inside the function. */
|
gcc_assert (new_block == DECL_INITIAL (current_function_decl));
|
gcc_assert (new_block == DECL_INITIAL (current_function_decl));
|
new_block = NULL;
|
new_block = NULL;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* We do not expect to handle duplicate blocks. */
|
/* We do not expect to handle duplicate blocks. */
|
gcc_assert (!TREE_ASM_WRITTEN (new_block));
|
gcc_assert (!TREE_ASM_WRITTEN (new_block));
|
TREE_ASM_WRITTEN (new_block) = 1;
|
TREE_ASM_WRITTEN (new_block) = 1;
|
|
|
/* Block tree may get clobbered by inlining. Normally this would
|
/* Block tree may get clobbered by inlining. Normally this would
|
be fixed in rest_of_decl_compilation using block notes, but
|
be fixed in rest_of_decl_compilation using block notes, but
|
since we are not going to emit them, it is up to us. */
|
since we are not going to emit them, it is up to us. */
|
BLOCK_CHAIN (new_block) = BLOCK_SUBBLOCKS (old_block);
|
BLOCK_CHAIN (new_block) = BLOCK_SUBBLOCKS (old_block);
|
BLOCK_SUBBLOCKS (old_block) = new_block;
|
BLOCK_SUBBLOCKS (old_block) = new_block;
|
BLOCK_SUBBLOCKS (new_block) = NULL_TREE;
|
BLOCK_SUBBLOCKS (new_block) = NULL_TREE;
|
BLOCK_SUPERCONTEXT (new_block) = old_block;
|
BLOCK_SUPERCONTEXT (new_block) = old_block;
|
|
|
data->block = new_block;
|
data->block = new_block;
|
}
|
}
|
}
|
}
|
|
|
record_vars (gimple_bind_vars (stmt));
|
record_vars (gimple_bind_vars (stmt));
|
lower_sequence (gimple_bind_body (stmt), data);
|
lower_sequence (gimple_bind_body (stmt), data);
|
|
|
if (new_block)
|
if (new_block)
|
{
|
{
|
gcc_assert (data->block == new_block);
|
gcc_assert (data->block == new_block);
|
|
|
BLOCK_SUBBLOCKS (new_block)
|
BLOCK_SUBBLOCKS (new_block)
|
= blocks_nreverse (BLOCK_SUBBLOCKS (new_block));
|
= blocks_nreverse (BLOCK_SUBBLOCKS (new_block));
|
data->block = old_block;
|
data->block = old_block;
|
}
|
}
|
|
|
/* The GIMPLE_BIND no longer carries any useful information -- kill it. */
|
/* The GIMPLE_BIND no longer carries any useful information -- kill it. */
|
gsi_insert_seq_before (gsi, gimple_bind_body (stmt), GSI_SAME_STMT);
|
gsi_insert_seq_before (gsi, gimple_bind_body (stmt), GSI_SAME_STMT);
|
gsi_remove (gsi, false);
|
gsi_remove (gsi, false);
|
}
|
}
|
|
|
/* Try to determine whether a TRY_CATCH expression can fall through.
|
/* Try to determine whether a TRY_CATCH expression can fall through.
|
This is a subroutine of block_may_fallthru. */
|
This is a subroutine of block_may_fallthru. */
|
|
|
static bool
|
static bool
|
try_catch_may_fallthru (const_tree stmt)
|
try_catch_may_fallthru (const_tree stmt)
|
{
|
{
|
tree_stmt_iterator i;
|
tree_stmt_iterator i;
|
|
|
/* If the TRY block can fall through, the whole TRY_CATCH can
|
/* If the TRY block can fall through, the whole TRY_CATCH can
|
fall through. */
|
fall through. */
|
if (block_may_fallthru (TREE_OPERAND (stmt, 0)))
|
if (block_may_fallthru (TREE_OPERAND (stmt, 0)))
|
return true;
|
return true;
|
|
|
i = tsi_start (TREE_OPERAND (stmt, 1));
|
i = tsi_start (TREE_OPERAND (stmt, 1));
|
switch (TREE_CODE (tsi_stmt (i)))
|
switch (TREE_CODE (tsi_stmt (i)))
|
{
|
{
|
case CATCH_EXPR:
|
case CATCH_EXPR:
|
/* We expect to see a sequence of CATCH_EXPR trees, each with a
|
/* We expect to see a sequence of CATCH_EXPR trees, each with a
|
catch expression and a body. The whole TRY_CATCH may fall
|
catch expression and a body. The whole TRY_CATCH may fall
|
through iff any of the catch bodies falls through. */
|
through iff any of the catch bodies falls through. */
|
for (; !tsi_end_p (i); tsi_next (&i))
|
for (; !tsi_end_p (i); tsi_next (&i))
|
{
|
{
|
if (block_may_fallthru (CATCH_BODY (tsi_stmt (i))))
|
if (block_may_fallthru (CATCH_BODY (tsi_stmt (i))))
|
return true;
|
return true;
|
}
|
}
|
return false;
|
return false;
|
|
|
case EH_FILTER_EXPR:
|
case EH_FILTER_EXPR:
|
/* The exception filter expression only matters if there is an
|
/* The exception filter expression only matters if there is an
|
exception. If the exception does not match EH_FILTER_TYPES,
|
exception. If the exception does not match EH_FILTER_TYPES,
|
we will execute EH_FILTER_FAILURE, and we will fall through
|
we will execute EH_FILTER_FAILURE, and we will fall through
|
if that falls through. If the exception does match
|
if that falls through. If the exception does match
|
EH_FILTER_TYPES, the stack unwinder will continue up the
|
EH_FILTER_TYPES, the stack unwinder will continue up the
|
stack, so we will not fall through. We don't know whether we
|
stack, so we will not fall through. We don't know whether we
|
will throw an exception which matches EH_FILTER_TYPES or not,
|
will throw an exception which matches EH_FILTER_TYPES or not,
|
so we just ignore EH_FILTER_TYPES and assume that we might
|
so we just ignore EH_FILTER_TYPES and assume that we might
|
throw an exception which doesn't match. */
|
throw an exception which doesn't match. */
|
return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i)));
|
return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i)));
|
|
|
default:
|
default:
|
/* This case represents statements to be executed when an
|
/* This case represents statements to be executed when an
|
exception occurs. Those statements are implicitly followed
|
exception occurs. Those statements are implicitly followed
|
by a RESX statement to resume execution after the exception.
|
by a RESX statement to resume execution after the exception.
|
So in this case the TRY_CATCH never falls through. */
|
So in this case the TRY_CATCH never falls through. */
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Same as above, but for a GIMPLE_TRY_CATCH. */
|
/* Same as above, but for a GIMPLE_TRY_CATCH. */
|
|
|
static bool
|
static bool
|
gimple_try_catch_may_fallthru (gimple stmt)
|
gimple_try_catch_may_fallthru (gimple stmt)
|
{
|
{
|
gimple_stmt_iterator i;
|
gimple_stmt_iterator i;
|
|
|
/* We don't handle GIMPLE_TRY_FINALLY. */
|
/* We don't handle GIMPLE_TRY_FINALLY. */
|
gcc_assert (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH);
|
gcc_assert (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH);
|
|
|
/* If the TRY block can fall through, the whole TRY_CATCH can
|
/* If the TRY block can fall through, the whole TRY_CATCH can
|
fall through. */
|
fall through. */
|
if (gimple_seq_may_fallthru (gimple_try_eval (stmt)))
|
if (gimple_seq_may_fallthru (gimple_try_eval (stmt)))
|
return true;
|
return true;
|
|
|
i = gsi_start (gimple_try_cleanup (stmt));
|
i = gsi_start (gimple_try_cleanup (stmt));
|
switch (gimple_code (gsi_stmt (i)))
|
switch (gimple_code (gsi_stmt (i)))
|
{
|
{
|
case GIMPLE_CATCH:
|
case GIMPLE_CATCH:
|
/* We expect to see a sequence of GIMPLE_CATCH stmts, each with a
|
/* We expect to see a sequence of GIMPLE_CATCH stmts, each with a
|
catch expression and a body. The whole try/catch may fall
|
catch expression and a body. The whole try/catch may fall
|
through iff any of the catch bodies falls through. */
|
through iff any of the catch bodies falls through. */
|
for (; !gsi_end_p (i); gsi_next (&i))
|
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 (gsi_stmt (i))))
|
return true;
|
return true;
|
}
|
}
|
return false;
|
return false;
|
|
|
case GIMPLE_EH_FILTER:
|
case GIMPLE_EH_FILTER:
|
/* The exception filter expression only matters if there is an
|
/* The exception filter expression only matters if there is an
|
exception. If the exception does not match EH_FILTER_TYPES,
|
exception. If the exception does not match EH_FILTER_TYPES,
|
we will execute EH_FILTER_FAILURE, and we will fall through
|
we will execute EH_FILTER_FAILURE, and we will fall through
|
if that falls through. If the exception does match
|
if that falls through. If the exception does match
|
EH_FILTER_TYPES, the stack unwinder will continue up the
|
EH_FILTER_TYPES, the stack unwinder will continue up the
|
stack, so we will not fall through. We don't know whether we
|
stack, so we will not fall through. We don't know whether we
|
will throw an exception which matches EH_FILTER_TYPES or not,
|
will throw an exception which matches EH_FILTER_TYPES or not,
|
so we just ignore EH_FILTER_TYPES and assume that we might
|
so we just ignore EH_FILTER_TYPES and assume that we might
|
throw an exception which doesn't match. */
|
throw an exception which doesn't match. */
|
return gimple_seq_may_fallthru (gimple_eh_filter_failure (gsi_stmt (i)));
|
return gimple_seq_may_fallthru (gimple_eh_filter_failure (gsi_stmt (i)));
|
|
|
default:
|
default:
|
/* This case represents statements to be executed when an
|
/* This case represents statements to be executed when an
|
exception occurs. Those statements are implicitly followed
|
exception occurs. Those statements are implicitly followed
|
by a GIMPLE_RESX to resume execution after the exception. So
|
by a GIMPLE_RESX to resume execution after the exception. So
|
in this case the try/catch never falls through. */
|
in this case the try/catch never falls through. */
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Try to determine if we can fall out of the bottom of BLOCK. This guess
|
/* 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
|
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.
|
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. */
|
If we're wrong, we'll just delete the extra code later. */
|
|
|
bool
|
bool
|
block_may_fallthru (const_tree block)
|
block_may_fallthru (const_tree block)
|
{
|
{
|
/* This CONST_CAST is okay because expr_last returns its argument
|
/* This CONST_CAST is okay because expr_last returns its argument
|
unmodified and we assign it to a const_tree. */
|
unmodified and we assign it to a const_tree. */
|
const_tree stmt = expr_last (CONST_CAST_TREE(block));
|
const_tree stmt = expr_last (CONST_CAST_TREE(block));
|
|
|
switch (stmt ? TREE_CODE (stmt) : ERROR_MARK)
|
switch (stmt ? TREE_CODE (stmt) : ERROR_MARK)
|
{
|
{
|
case GOTO_EXPR:
|
case GOTO_EXPR:
|
case RETURN_EXPR:
|
case RETURN_EXPR:
|
/* Easy cases. If the last statement of the block implies
|
/* Easy cases. If the last statement of the block implies
|
control transfer, then we can't fall through. */
|
control transfer, then we can't fall through. */
|
return false;
|
return false;
|
|
|
case SWITCH_EXPR:
|
case SWITCH_EXPR:
|
/* If SWITCH_LABELS is set, this is lowered, and represents a
|
/* If SWITCH_LABELS is set, this is lowered, and represents a
|
branch to a selected label and hence can not fall through.
|
branch to a selected label and hence can not fall through.
|
Otherwise SWITCH_BODY is set, and the switch can fall
|
Otherwise SWITCH_BODY is set, and the switch can fall
|
through. */
|
through. */
|
return SWITCH_LABELS (stmt) == NULL_TREE;
|
return SWITCH_LABELS (stmt) == NULL_TREE;
|
|
|
case COND_EXPR:
|
case COND_EXPR:
|
if (block_may_fallthru (COND_EXPR_THEN (stmt)))
|
if (block_may_fallthru (COND_EXPR_THEN (stmt)))
|
return true;
|
return true;
|
return block_may_fallthru (COND_EXPR_ELSE (stmt));
|
return block_may_fallthru (COND_EXPR_ELSE (stmt));
|
|
|
case BIND_EXPR:
|
case BIND_EXPR:
|
return block_may_fallthru (BIND_EXPR_BODY (stmt));
|
return block_may_fallthru (BIND_EXPR_BODY (stmt));
|
|
|
case TRY_CATCH_EXPR:
|
case TRY_CATCH_EXPR:
|
return try_catch_may_fallthru (stmt);
|
return try_catch_may_fallthru (stmt);
|
|
|
case TRY_FINALLY_EXPR:
|
case TRY_FINALLY_EXPR:
|
/* The finally clause is always executed after the try clause,
|
/* The finally clause is always executed after the try clause,
|
so if it does not fall through, then the try-finally will not
|
so if it does not fall through, then the try-finally will not
|
fall through. Otherwise, if the try clause does not fall
|
fall through. Otherwise, if the try clause does not fall
|
through, then when the finally clause falls through it will
|
through, then when the finally clause falls through it will
|
resume execution wherever the try clause was going. So the
|
resume execution wherever the try clause was going. So the
|
whole try-finally will only fall through if both the try
|
whole try-finally will only fall through if both the try
|
clause and the finally clause fall through. */
|
clause and the finally clause fall through. */
|
return (block_may_fallthru (TREE_OPERAND (stmt, 0))
|
return (block_may_fallthru (TREE_OPERAND (stmt, 0))
|
&& block_may_fallthru (TREE_OPERAND (stmt, 1)));
|
&& block_may_fallthru (TREE_OPERAND (stmt, 1)));
|
|
|
case MODIFY_EXPR:
|
case MODIFY_EXPR:
|
if (TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR)
|
if (TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR)
|
stmt = TREE_OPERAND (stmt, 1);
|
stmt = TREE_OPERAND (stmt, 1);
|
else
|
else
|
return true;
|
return true;
|
/* FALLTHRU */
|
/* FALLTHRU */
|
|
|
case CALL_EXPR:
|
case CALL_EXPR:
|
/* Functions that do not return do not fall through. */
|
/* Functions that do not return do not fall through. */
|
return (call_expr_flags (stmt) & ECF_NORETURN) == 0;
|
return (call_expr_flags (stmt) & ECF_NORETURN) == 0;
|
|
|
case CLEANUP_POINT_EXPR:
|
case CLEANUP_POINT_EXPR:
|
return block_may_fallthru (TREE_OPERAND (stmt, 0));
|
return block_may_fallthru (TREE_OPERAND (stmt, 0));
|
|
|
default:
|
default:
|
return true;
|
return true;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Try to determine if we can continue executing the statement
|
/* Try to determine if we can continue executing the statement
|
immediately following STMT. This guess need not be 100% accurate;
|
immediately following STMT. This guess need not be 100% accurate;
|
simply be conservative and return true if we don't know. This is
|
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,
|
used only to avoid stupidly generating extra code. If we're wrong,
|
we'll just delete the extra code later. */
|
we'll just delete the extra code later. */
|
|
|
bool
|
bool
|
gimple_stmt_may_fallthru (gimple stmt)
|
gimple_stmt_may_fallthru (gimple stmt)
|
{
|
{
|
if (!stmt)
|
if (!stmt)
|
return true;
|
return true;
|
|
|
switch (gimple_code (stmt))
|
switch (gimple_code (stmt))
|
{
|
{
|
case GIMPLE_GOTO:
|
case GIMPLE_GOTO:
|
case GIMPLE_RETURN:
|
case GIMPLE_RETURN:
|
case GIMPLE_RESX:
|
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. */
|
control transfer, then we can't fall through. */
|
return false;
|
return false;
|
|
|
case GIMPLE_SWITCH:
|
case GIMPLE_SWITCH:
|
/* Switch has already been lowered and represents a branch
|
/* Switch has already been lowered and represents a branch
|
to a selected label and hence can't fall through. */
|
to a selected label and hence can't fall through. */
|
return false;
|
return false;
|
|
|
case GIMPLE_COND:
|
case GIMPLE_COND:
|
/* GIMPLE_COND's are already lowered into a two-way branch. They
|
/* GIMPLE_COND's are already lowered into a two-way branch. They
|
can't fall through. */
|
can't fall through. */
|
return false;
|
return false;
|
|
|
case GIMPLE_BIND:
|
case GIMPLE_BIND:
|
return gimple_seq_may_fallthru (gimple_bind_body (stmt));
|
return gimple_seq_may_fallthru (gimple_bind_body (stmt));
|
|
|
case GIMPLE_TRY:
|
case GIMPLE_TRY:
|
if (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH)
|
if (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH)
|
return gimple_try_catch_may_fallthru (stmt);
|
return gimple_try_catch_may_fallthru (stmt);
|
|
|
/* It must be a GIMPLE_TRY_FINALLY. */
|
/* It must be a GIMPLE_TRY_FINALLY. */
|
|
|
/* The finally clause is always executed after the try clause,
|
/* The finally clause is always executed after the try clause,
|
so if it does not fall through, then the try-finally will not
|
so if it does not fall through, then the try-finally will not
|
fall through. Otherwise, if the try clause does not fall
|
fall through. Otherwise, if the try clause does not fall
|
through, then when the finally clause falls through it will
|
through, then when the finally clause falls through it will
|
resume execution wherever the try clause was going. So the
|
resume execution wherever the try clause was going. So the
|
whole try-finally will only fall through if both the try
|
whole try-finally will only fall through if both the try
|
clause and the finally clause fall through. */
|
clause and the finally clause fall through. */
|
return (gimple_seq_may_fallthru (gimple_try_eval (stmt))
|
return (gimple_seq_may_fallthru (gimple_try_eval (stmt))
|
&& gimple_seq_may_fallthru (gimple_try_cleanup (stmt)));
|
&& gimple_seq_may_fallthru (gimple_try_cleanup (stmt)));
|
|
|
case GIMPLE_CALL:
|
case GIMPLE_CALL:
|
/* Functions that do not return do not fall through. */
|
/* Functions that do not return do not fall through. */
|
return (gimple_call_flags (stmt) & ECF_NORETURN) == 0;
|
return (gimple_call_flags (stmt) & ECF_NORETURN) == 0;
|
|
|
default:
|
default:
|
return true;
|
return true;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Same as gimple_stmt_may_fallthru, but for the gimple sequence SEQ. */
|
/* Same as gimple_stmt_may_fallthru, but for the gimple sequence SEQ. */
|
|
|
bool
|
bool
|
gimple_seq_may_fallthru (gimple_seq seq)
|
gimple_seq_may_fallthru (gimple_seq seq)
|
{
|
{
|
return gimple_stmt_may_fallthru (gimple_seq_last_stmt (seq));
|
return gimple_stmt_may_fallthru (gimple_seq_last_stmt (seq));
|
}
|
}
|
|
|
|
|
/* Lower a GIMPLE_RETURN GSI. DATA is passed through the recursion. */
|
/* Lower a GIMPLE_RETURN GSI. DATA is passed through the recursion. */
|
|
|
static void
|
static void
|
lower_gimple_return (gimple_stmt_iterator *gsi, struct lower_data *data)
|
lower_gimple_return (gimple_stmt_iterator *gsi, struct lower_data *data)
|
{
|
{
|
gimple stmt = gsi_stmt (*gsi);
|
gimple stmt = gsi_stmt (*gsi);
|
gimple t;
|
gimple t;
|
int i;
|
int i;
|
return_statements_t tmp_rs;
|
return_statements_t tmp_rs;
|
|
|
/* Match this up with an existing return statement that's been created. */
|
/* 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 = VEC_length (return_statements_t, data->return_statements) - 1;
|
i >= 0; i--)
|
i >= 0; i--)
|
{
|
{
|
tmp_rs = *VEC_index (return_statements_t, data->return_statements, i);
|
tmp_rs = *VEC_index (return_statements_t, data->return_statements, i);
|
|
|
if (gimple_return_retval (stmt) == gimple_return_retval (tmp_rs.stmt))
|
if (gimple_return_retval (stmt) == gimple_return_retval (tmp_rs.stmt))
|
goto found;
|
goto found;
|
}
|
}
|
|
|
/* Not found. Create a new label and record the return statement. */
|
/* Not found. Create a new label and record the return statement. */
|
tmp_rs.label = create_artificial_label (cfun->function_end_locus);
|
tmp_rs.label = create_artificial_label (cfun->function_end_locus);
|
tmp_rs.stmt = stmt;
|
tmp_rs.stmt = stmt;
|
VEC_safe_push (return_statements_t, heap, data->return_statements, &tmp_rs);
|
VEC_safe_push (return_statements_t, heap, data->return_statements, &tmp_rs);
|
|
|
/* Generate a goto statement and remove the return statement. */
|
/* Generate a goto statement and remove the return statement. */
|
found:
|
found:
|
t = gimple_build_goto (tmp_rs.label);
|
t = gimple_build_goto (tmp_rs.label);
|
gimple_set_location (t, gimple_location (stmt));
|
gimple_set_location (t, gimple_location (stmt));
|
gimple_set_block (t, gimple_block (stmt));
|
gimple_set_block (t, gimple_block (stmt));
|
gsi_insert_before (gsi, t, GSI_SAME_STMT);
|
gsi_insert_before (gsi, t, GSI_SAME_STMT);
|
gsi_remove (gsi, false);
|
gsi_remove (gsi, false);
|
}
|
}
|
|
|
/* Lower a __builtin_setjmp GSI.
|
/* Lower a __builtin_setjmp GSI.
|
|
|
__builtin_setjmp is passed a pointer to an array of five words (not
|
__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
|
all will be used on all machines). It operates similarly to the C
|
library function of the same name, but is more efficient.
|
library function of the same name, but is more efficient.
|
|
|
It is lowered into 3 other builtins, namely __builtin_setjmp_setup,
|
It is lowered into 3 other builtins, namely __builtin_setjmp_setup,
|
__builtin_setjmp_dispatcher and __builtin_setjmp_receiver, but with
|
__builtin_setjmp_dispatcher and __builtin_setjmp_receiver, but with
|
__builtin_setjmp_dispatcher shared among all the instances; that's
|
__builtin_setjmp_dispatcher shared among all the instances; that's
|
why it is only emitted at the end by lower_function_body.
|
why it is only emitted at the end by lower_function_body.
|
|
|
After full lowering, the body of the function should look like:
|
After full lowering, the body of the function should look like:
|
|
|
{
|
{
|
void * setjmpvar.0;
|
void * setjmpvar.0;
|
int D.1844;
|
int D.1844;
|
int D.2844;
|
int D.2844;
|
|
|
[...]
|
[...]
|
|
|
__builtin_setjmp_setup (&buf, &<D1847>);
|
__builtin_setjmp_setup (&buf, &<D1847>);
|
D.1844 = 0;
|
D.1844 = 0;
|
goto <D1846>;
|
goto <D1846>;
|
<D1847>:;
|
<D1847>:;
|
__builtin_setjmp_receiver (&<D1847>);
|
__builtin_setjmp_receiver (&<D1847>);
|
D.1844 = 1;
|
D.1844 = 1;
|
<D1846>:;
|
<D1846>:;
|
if (D.1844 == 0) goto <D1848>; else goto <D1849>;
|
if (D.1844 == 0) goto <D1848>; else goto <D1849>;
|
|
|
[...]
|
[...]
|
|
|
__builtin_setjmp_setup (&buf, &<D2847>);
|
__builtin_setjmp_setup (&buf, &<D2847>);
|
D.2844 = 0;
|
D.2844 = 0;
|
goto <D2846>;
|
goto <D2846>;
|
<D2847>:;
|
<D2847>:;
|
__builtin_setjmp_receiver (&<D2847>);
|
__builtin_setjmp_receiver (&<D2847>);
|
D.2844 = 1;
|
D.2844 = 1;
|
<D2846>:;
|
<D2846>:;
|
if (D.2844 == 0) goto <D2848>; else goto <D2849>;
|
if (D.2844 == 0) goto <D2848>; else goto <D2849>;
|
|
|
[...]
|
[...]
|
|
|
<D3850>:;
|
<D3850>:;
|
return;
|
return;
|
<D3853>: [non-local];
|
<D3853>: [non-local];
|
setjmpvar.0 = __builtin_setjmp_dispatcher (&<D3853>);
|
setjmpvar.0 = __builtin_setjmp_dispatcher (&<D3853>);
|
goto setjmpvar.0;
|
goto setjmpvar.0;
|
}
|
}
|
|
|
The dispatcher block will be both the unique destination of all the
|
The dispatcher block will be both the unique destination of all the
|
abnormal call edges and the unique source of all the abnormal edges
|
abnormal call edges and the unique source of all the abnormal edges
|
to the receivers, thus keeping the complexity explosion localized. */
|
to the receivers, thus keeping the complexity explosion localized. */
|
|
|
static void
|
static void
|
lower_builtin_setjmp (gimple_stmt_iterator *gsi)
|
lower_builtin_setjmp (gimple_stmt_iterator *gsi)
|
{
|
{
|
gimple stmt = gsi_stmt (*gsi);
|
gimple stmt = gsi_stmt (*gsi);
|
location_t loc = gimple_location (stmt);
|
location_t loc = gimple_location (stmt);
|
tree cont_label = create_artificial_label (loc);
|
tree cont_label = create_artificial_label (loc);
|
tree next_label = create_artificial_label (loc);
|
tree next_label = create_artificial_label (loc);
|
tree dest, t, arg;
|
tree dest, t, arg;
|
gimple g;
|
gimple g;
|
|
|
/* NEXT_LABEL is the label __builtin_longjmp will jump to. Its address is
|
/* NEXT_LABEL is the label __builtin_longjmp will jump to. Its address is
|
passed to both __builtin_setjmp_setup and __builtin_setjmp_receiver. */
|
passed to both __builtin_setjmp_setup and __builtin_setjmp_receiver. */
|
FORCED_LABEL (next_label) = 1;
|
FORCED_LABEL (next_label) = 1;
|
|
|
dest = gimple_call_lhs (stmt);
|
dest = gimple_call_lhs (stmt);
|
|
|
/* Build '__builtin_setjmp_setup (BUF, NEXT_LABEL)' and insert. */
|
/* Build '__builtin_setjmp_setup (BUF, NEXT_LABEL)' and insert. */
|
arg = build_addr (next_label, current_function_decl);
|
arg = build_addr (next_label, current_function_decl);
|
t = implicit_built_in_decls[BUILT_IN_SETJMP_SETUP];
|
t = implicit_built_in_decls[BUILT_IN_SETJMP_SETUP];
|
g = gimple_build_call (t, 2, gimple_call_arg (stmt, 0), arg);
|
g = gimple_build_call (t, 2, gimple_call_arg (stmt, 0), arg);
|
gimple_set_location (g, loc);
|
gimple_set_location (g, loc);
|
gimple_set_block (g, gimple_block (stmt));
|
gimple_set_block (g, gimple_block (stmt));
|
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
|
|
/* Build 'DEST = 0' and insert. */
|
/* Build 'DEST = 0' and insert. */
|
if (dest)
|
if (dest)
|
{
|
{
|
g = gimple_build_assign (dest, fold_convert_loc (loc, TREE_TYPE (dest),
|
g = gimple_build_assign (dest, fold_convert_loc (loc, TREE_TYPE (dest),
|
integer_zero_node));
|
integer_zero_node));
|
gimple_set_location (g, loc);
|
gimple_set_location (g, loc);
|
gimple_set_block (g, gimple_block (stmt));
|
gimple_set_block (g, gimple_block (stmt));
|
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
}
|
}
|
|
|
/* Build 'goto CONT_LABEL' and insert. */
|
/* Build 'goto CONT_LABEL' and insert. */
|
g = gimple_build_goto (cont_label);
|
g = gimple_build_goto (cont_label);
|
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
|
|
/* Build 'NEXT_LABEL:' and insert. */
|
/* Build 'NEXT_LABEL:' and insert. */
|
g = gimple_build_label (next_label);
|
g = gimple_build_label (next_label);
|
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
|
|
/* Build '__builtin_setjmp_receiver (NEXT_LABEL)' and insert. */
|
/* Build '__builtin_setjmp_receiver (NEXT_LABEL)' and insert. */
|
arg = build_addr (next_label, current_function_decl);
|
arg = build_addr (next_label, current_function_decl);
|
t = implicit_built_in_decls[BUILT_IN_SETJMP_RECEIVER];
|
t = implicit_built_in_decls[BUILT_IN_SETJMP_RECEIVER];
|
g = gimple_build_call (t, 1, arg);
|
g = gimple_build_call (t, 1, arg);
|
gimple_set_location (g, loc);
|
gimple_set_location (g, loc);
|
gimple_set_block (g, gimple_block (stmt));
|
gimple_set_block (g, gimple_block (stmt));
|
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
|
|
/* Build 'DEST = 1' and insert. */
|
/* Build 'DEST = 1' and insert. */
|
if (dest)
|
if (dest)
|
{
|
{
|
g = gimple_build_assign (dest, fold_convert_loc (loc, TREE_TYPE (dest),
|
g = gimple_build_assign (dest, fold_convert_loc (loc, TREE_TYPE (dest),
|
integer_one_node));
|
integer_one_node));
|
gimple_set_location (g, loc);
|
gimple_set_location (g, loc);
|
gimple_set_block (g, gimple_block (stmt));
|
gimple_set_block (g, gimple_block (stmt));
|
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
}
|
}
|
|
|
/* Build 'CONT_LABEL:' and insert. */
|
/* Build 'CONT_LABEL:' and insert. */
|
g = gimple_build_label (cont_label);
|
g = gimple_build_label (cont_label);
|
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
gsi_insert_before (gsi, g, GSI_SAME_STMT);
|
|
|
/* Remove the call to __builtin_setjmp. */
|
/* Remove the call to __builtin_setjmp. */
|
gsi_remove (gsi, false);
|
gsi_remove (gsi, false);
|
}
|
}
|
|
|
|
|
/* Record the variables in VARS into function FN. */
|
/* Record the variables in VARS into function FN. */
|
|
|
void
|
void
|
record_vars_into (tree vars, tree fn)
|
record_vars_into (tree vars, tree fn)
|
{
|
{
|
if (fn != current_function_decl)
|
if (fn != current_function_decl)
|
push_cfun (DECL_STRUCT_FUNCTION (fn));
|
push_cfun (DECL_STRUCT_FUNCTION (fn));
|
|
|
for (; vars; vars = TREE_CHAIN (vars))
|
for (; vars; vars = TREE_CHAIN (vars))
|
{
|
{
|
tree var = vars;
|
tree var = vars;
|
|
|
/* BIND_EXPRs contains also function/type/constant declarations
|
/* BIND_EXPRs contains also function/type/constant declarations
|
we don't need to care about. */
|
we don't need to care about. */
|
if (TREE_CODE (var) != VAR_DECL)
|
if (TREE_CODE (var) != VAR_DECL)
|
continue;
|
continue;
|
|
|
/* Nothing to do in this case. */
|
/* Nothing to do in this case. */
|
if (DECL_EXTERNAL (var))
|
if (DECL_EXTERNAL (var))
|
continue;
|
continue;
|
|
|
/* Record the variable. */
|
/* Record the variable. */
|
cfun->local_decls = tree_cons (NULL_TREE, var,
|
cfun->local_decls = tree_cons (NULL_TREE, var,
|
cfun->local_decls);
|
cfun->local_decls);
|
}
|
}
|
|
|
if (fn != current_function_decl)
|
if (fn != current_function_decl)
|
pop_cfun ();
|
pop_cfun ();
|
}
|
}
|
|
|
|
|
/* Record the variables in VARS into current_function_decl. */
|
/* Record the variables in VARS into current_function_decl. */
|
|
|
void
|
void
|
record_vars (tree vars)
|
record_vars (tree vars)
|
{
|
{
|
record_vars_into (vars, current_function_decl);
|
record_vars_into (vars, current_function_decl);
|
}
|
}
|
|
|
