OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

re PR tree-optimization/51363 (ICE: in gimple_rhs_has_side_effects, at gimple.c:2530 with -O -fno-tree-ccp) 

2011-12-06  Richard Guenther  <rguenther@suse.de>

	PR tree-optimization/51363
	* gimple.c (gimple_rhs_has_side_effects): Remove.
	* gimple.h (gimple_rhs_has_side_effects): Likewise.
	* tree-ssa-dom.c (optimize_stmt): Simplify conditional.

From-SVN: r182041
This commit is contained in:
Richard Guenther 2011-12-06 09:02:17 +00:00 committed by Richard Biener
parent 59b719ec82
commit d829c408d2
4 changed files with 10 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
gcc/ChangeLog
View File

@ -1,3 +1,10 @@
2011-12-06 Richard Guenther <rguenther@suse.de>
PR tree-optimization/51363
* gimple.c (gimple_rhs_has_side_effects): Remove.
* gimple.h (gimple_rhs_has_side_effects): Likewise.
* tree-ssa-dom.c (optimize_stmt): Simplify conditional.
2011-12-06 Alan Modra <amodra@gmail.com>
PR target/50906

63
gcc/gimple.c
View File

@ -2484,69 +2484,6 @@ gimple_has_side_effects (const_gimple s)
return false;
}
/* Return true if the RHS of statement S has side effects.
We may use it to determine if it is admissable to replace
an assignment or call with a copy of a previously-computed
value. In such cases, side-effects due to the LHS are
preserved. */
bool
gimple_rhs_has_side_effects (const_gimple s)
{
unsigned i;
if (is_gimple_call (s))
{
unsigned nargs = gimple_call_num_args (s);
tree fn;
if (!(gimple_call_flags (s) & (ECF_CONST | ECF_PURE)))
return true;
/* We cannot use gimple_has_volatile_ops here,
because we must ignore a volatile LHS. */
fn = gimple_call_fn (s);
if (fn && (TREE_SIDE_EFFECTS (fn) || TREE_THIS_VOLATILE (fn)))
{
gcc_assert (gimple_has_volatile_ops (s));
return true;
}
for (i = 0; i < nargs; i++)
if (TREE_SIDE_EFFECTS (gimple_call_arg (s, i))
|| TREE_THIS_VOLATILE (gimple_call_arg (s, i)))
return true;
return false;
}
else if (is_gimple_assign (s))
{
/* Skip the first operand, the LHS. */
for (i = 1; i < gimple_num_ops (s); i++)
if (TREE_SIDE_EFFECTS (gimple_op (s, i))
|| TREE_THIS_VOLATILE (gimple_op (s, i)))
{
gcc_assert (gimple_has_volatile_ops (s));
return true;
}
}
else if (is_gimple_debug (s))
return false;
else
{
/* For statements without an LHS, examine all arguments. */
for (i = 0; i < gimple_num_ops (s); i++)
if (TREE_SIDE_EFFECTS (gimple_op (s, i))
|| TREE_THIS_VOLATILE (gimple_op (s, i)))
{
gcc_assert (gimple_has_volatile_ops (s));
return true;
}
}
return false;
}
/* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
Return true if S can trap. When INCLUDE_MEM is true, check whether
the memory operations could trap. When INCLUDE_STORES is true and

1
gcc/gimple.h
View File

@ -948,7 +948,6 @@ void gimple_cond_get_ops_from_tree (tree, enum tree_code *, tree *, tree *);
gimple gimple_build_cond_from_tree (tree, tree, tree);
void gimple_cond_set_condition_from_tree (gimple, tree);
bool gimple_has_side_effects (const_gimple);
bool gimple_rhs_has_side_effects (const_gimple);
bool gimple_could_trap_p (gimple);
bool gimple_could_trap_p_1 (gimple, bool, bool);
bool gimple_assign_rhs_could_trap_p (gimple);

8
gcc/tree-ssa-dom.c
View File

@ -2154,12 +2154,10 @@ optimize_stmt (basic_block bb, gimple_stmt_iterator si)
/* Check for redundant computations. Do this optimization only
for assignments that have no volatile ops and conditionals. */
may_optimize_p = (!gimple_has_volatile_ops (stmt)
&& ((is_gimple_assign (stmt)
&& !gimple_rhs_has_side_effects (stmt))
may_optimize_p = (!gimple_has_side_effects (stmt)
&& (is_gimple_assign (stmt)
|| (is_gimple_call (stmt)
&& gimple_call_lhs (stmt) != NULL_TREE
&& !gimple_rhs_has_side_effects (stmt))
&& gimple_call_lhs (stmt) != NULL_TREE)
|| gimple_code (stmt) == GIMPLE_COND
|| gimple_code (stmt) == GIMPLE_SWITCH));