Commit 66e8b99c by Richard Guenther Committed by Richard Biener

re PR tree-optimization/38645 (ICE with volatile)

2008-12-30  Richard Guenther  <rguenther@suse.de>

	PR tree-optimization/38645
	* tree-ssa-ccp.c (fold_gimple_assign): Use the correct pointer
	type.
	* tree-ssa-dom.c (cprop_operand): Simplify.  Do not propagate
	volatileness changing operands.

	* gcc.dg/pr38645.c: New testcase.

From-SVN: r142967
parent c13edb67
2008-12-30 Richard Guenther <rguenther@suse.de>
PR tree-optimization/38645
* tree-ssa-ccp.c (fold_gimple_assign): Use the correct pointer
type.
* tree-ssa-dom.c (cprop_operand): Simplify. Do not propagate
volatileness changing operands.
2008-12-30 Steven Bosscher <steven@gcc.gnu.org> 2008-12-30 Steven Bosscher <steven@gcc.gnu.org>
* tree-cfg.c (verify_eh_throw_stmt_node): Return nonzero, * tree-cfg.c (verify_eh_throw_stmt_node): Return nonzero,
2008-12-30 Richard Guenther <rguenther@suse.de>
PR tree-optimization/38645
* gcc.dg/pr38645.c: New testcase.
2008-12-30 Andrew Pinski <pinskia@gmail.com> 2008-12-30 Andrew Pinski <pinskia@gmail.com>
PR middle-end/38661 PR middle-end/38661
......
/* { dg-do compile } */
/* { dg-options "-O2 -fdump-tree-optimized" } */
int foo()
{
volatile int a[1];
int i, *p = (int*)a;
a[0] = 1;
for (i = 0; i < 1; ++i)
if (p[i])
return -1;
return 0;
}
/* { dg-final { scan-tree-dump "a.0. ={v} 1;" "optimized" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
...@@ -2720,10 +2720,19 @@ fold_gimple_assign (gimple_stmt_iterator *si) ...@@ -2720,10 +2720,19 @@ fold_gimple_assign (gimple_stmt_iterator *si)
case GIMPLE_BINARY_RHS: case GIMPLE_BINARY_RHS:
/* Try to fold pointer addition. */ /* Try to fold pointer addition. */
if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR) if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR)
result = maybe_fold_stmt_addition ( {
TREE_TYPE (gimple_assign_lhs (stmt)), tree type = TREE_TYPE (gimple_assign_rhs1 (stmt));
if (TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE)
{
type = build_pointer_type (TREE_TYPE (TREE_TYPE (type)));
if (!useless_type_conversion_p
(TREE_TYPE (gimple_assign_lhs (stmt)), type))
type = TREE_TYPE (gimple_assign_rhs1 (stmt));
}
result = maybe_fold_stmt_addition (type,
gimple_assign_rhs1 (stmt), gimple_assign_rhs1 (stmt),
gimple_assign_rhs2 (stmt)); gimple_assign_rhs2 (stmt));
}
if (!result) if (!result)
result = fold_binary (subcode, result = fold_binary (subcode,
......
...@@ -2045,8 +2045,6 @@ cprop_operand (gimple stmt, use_operand_p op_p) ...@@ -2045,8 +2045,6 @@ cprop_operand (gimple stmt, use_operand_p op_p)
val = SSA_NAME_VALUE (op); val = SSA_NAME_VALUE (op);
if (val && val != op) if (val && val != op)
{ {
tree op_type, val_type;
/* Do not change the base variable in the virtual operand /* Do not change the base variable in the virtual operand
tables. That would make it impossible to reconstruct tables. That would make it impossible to reconstruct
the renamed virtual operand if we later modify this the renamed virtual operand if we later modify this
...@@ -2063,36 +2061,18 @@ cprop_operand (gimple stmt, use_operand_p op_p) ...@@ -2063,36 +2061,18 @@ cprop_operand (gimple stmt, use_operand_p op_p)
&& !may_propagate_copy_into_asm (op)) && !may_propagate_copy_into_asm (op))
return false; return false;
/* Get the toplevel type of each operand. */
op_type = TREE_TYPE (op);
val_type = TREE_TYPE (val);
/* While both types are pointers, get the type of the object
pointed to. */
while (POINTER_TYPE_P (op_type) && POINTER_TYPE_P (val_type))
{
op_type = TREE_TYPE (op_type);
val_type = TREE_TYPE (val_type);
}
/* Make sure underlying types match before propagating a constant by
converting the constant to the proper type. Note that convert may
return a non-gimple expression, in which case we ignore this
propagation opportunity. */
if (TREE_CODE (val) != SSA_NAME)
{
if (!useless_type_conversion_p (op_type, val_type))
{
val = fold_convert (TREE_TYPE (op), val);
if (!is_gimple_min_invariant (val))
return false;
}
}
/* Certain operands are not allowed to be copy propagated due /* Certain operands are not allowed to be copy propagated due
to their interaction with exception handling and some GCC to their interaction with exception handling and some GCC
extensions. */ extensions. */
else if (!may_propagate_copy (op, val)) if (!may_propagate_copy (op, val))
return false;
/* Do not propagate addresses that point to volatiles into memory
stmts without volatile operands. */
if (POINTER_TYPE_P (TREE_TYPE (val))
&& TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (val)))
&& gimple_has_mem_ops (stmt)
&& !gimple_has_volatile_ops (stmt))
return false; return false;
/* Do not propagate copies if the propagated value is at a deeper loop /* Do not propagate copies if the propagated value is at a deeper loop
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment