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

gimple-fold.c (maybe_fold_reference): Open-code relevant constant folding. 

2011-03-16  Richard Guenther  <rguenther@suse.de>

	* gimple-fold.c (maybe_fold_reference): Open-code relevant
	constant folding.  Move MEM_REF canonicalization first.
	Rely on fold_const_aggregate_ref for initializer folding.
	* tree-ssa-ccp.c (ccp_fold): Handle constant vector extracts.

	* gcc.dg/tree-ssa/pr14814.c: Adjust.
	* gcc.dg/tree-ssa/ssa-ccp-19.c: Likewise.

From-SVN: r171043
This commit is contained in:
Richard Guenther 2011-03-16 11:36:30 +00:00 committed by Richard Biener
parent 29f10e7178
commit f0eddb9019
6 changed files with 66 additions and 48 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-03-16 Richard Guenther <rguenther@suse.de>
* gimple-fold.c (maybe_fold_reference): Open-code relevant
constant folding. Move MEM_REF canonicalization first.
Rely on fold_const_aggregate_ref for initializer folding.
* tree-ssa-ccp.c (ccp_fold): Handle constant vector extracts.
2011-03-16 Jakub Jelinek <jakub@redhat.com>
PR middle-end/48136

87
gcc/gimple-fold.c
View File

@ -560,24 +560,51 @@ maybe_fold_reference (tree expr, bool is_lhs)
tree *t = &expr;
tree result;
if ((TREE_CODE (expr) == VIEW_CONVERT_EXPR
|| TREE_CODE (expr) == REALPART_EXPR
|| TREE_CODE (expr) == IMAGPART_EXPR)
&& CONSTANT_CLASS_P (TREE_OPERAND (expr, 0)))
return fold_unary_loc (EXPR_LOCATION (expr),
TREE_CODE (expr),
TREE_TYPE (expr),
TREE_OPERAND (expr, 0));
else if (TREE_CODE (expr) == BIT_FIELD_REF
&& CONSTANT_CLASS_P (TREE_OPERAND (expr, 0)))
return fold_ternary_loc (EXPR_LOCATION (expr),
TREE_CODE (expr),
TREE_TYPE (expr),
TREE_OPERAND (expr, 0),
TREE_OPERAND (expr, 1),
TREE_OPERAND (expr, 2));
while (handled_component_p (*t))
t = &TREE_OPERAND (*t, 0);
/* Canonicalize MEM_REFs invariant address operand. Do this first
to avoid feeding non-canonical MEM_REFs elsewhere. */
if (TREE_CODE (*t) == MEM_REF
&& !is_gimple_mem_ref_addr (TREE_OPERAND (*t, 0)))
{
bool volatile_p = TREE_THIS_VOLATILE (*t);
tree tem = fold_binary (MEM_REF, TREE_TYPE (*t),
TREE_OPERAND (*t, 0),
TREE_OPERAND (*t, 1));
if (tem)
{
TREE_THIS_VOLATILE (tem) = volatile_p;
*t = tem;
tem = maybe_fold_reference (expr, is_lhs);
if (tem)
return tem;
return expr;
}
}
if (!is_lhs
&& (result = fold_const_aggregate_ref (expr))
&& is_gimple_min_invariant (result))
return result;
/* ??? We might want to open-code the relevant remaining cases
to avoid using the generic fold. */
if (handled_component_p (*t)
&& CONSTANT_CLASS_P (TREE_OPERAND (*t, 0)))
{
tree tem = fold (*t);
if (tem != *t)
return tem;
}
while (handled_component_p (*t))
t = &TREE_OPERAND (*t, 0);
/* Fold back MEM_REFs to reference trees. */
if (TREE_CODE (*t) == MEM_REF
&& TREE_CODE (TREE_OPERAND (*t, 0)) == ADDR_EXPR
@ -593,7 +620,7 @@ maybe_fold_reference (tree expr, bool is_lhs)
compatibility. */
&& types_compatible_p (TREE_TYPE (*t),
TREE_TYPE (TREE_OPERAND
(TREE_OPERAND (*t, 0), 0))))
(TREE_OPERAND (*t, 0), 0))))
{
tree tem;
*t = TREE_OPERAND (TREE_OPERAND (*t, 0), 0);
@ -602,24 +629,6 @@ maybe_fold_reference (tree expr, bool is_lhs)
return tem;
return expr;
}
/* Canonicalize MEM_REFs invariant address operand. */
else if (TREE_CODE (*t) == MEM_REF
&& !is_gimple_mem_ref_addr (TREE_OPERAND (*t, 0)))
{
bool volatile_p = TREE_THIS_VOLATILE (*t);
tree tem = fold_binary (MEM_REF, TREE_TYPE (*t),
TREE_OPERAND (*t, 0),
TREE_OPERAND (*t, 1));
if (tem)
{
TREE_THIS_VOLATILE (tem) = volatile_p;
*t = tem;
tem = maybe_fold_reference (expr, is_lhs);
if (tem)
return tem;
return expr;
}
}
else if (TREE_CODE (*t) == TARGET_MEM_REF)
{
tree tem = maybe_fold_tmr (*t);
@ -632,20 +641,6 @@ maybe_fold_reference (tree expr, bool is_lhs)
return expr;
}
}
else if (!is_lhs
&& DECL_P (*t))
{
tree tem = get_symbol_constant_value (*t);
if (tem
&& useless_type_conversion_p (TREE_TYPE (*t), TREE_TYPE (tem)))
{
*t = unshare_expr (tem);
tem = maybe_fold_reference (expr, is_lhs);
if (tem)
return tem;
return expr;
}
}
return NULL_TREE;
}

5
gcc/testsuite/ChangeLog
View File

@ -1,3 +1,8 @@
2011-03-16 Richard Guenther <rguenther@suse.de>
* gcc.dg/tree-ssa/pr14814.c: Adjust.
* gcc.dg/tree-ssa/ssa-ccp-19.c: Likewise.
2011-03-16 Jakub Jelinek <jakub@redhat.com>
PR middle-end/48136

2
gcc/testsuite/gcc.dg/tree-ssa/pr14814.c
View File

@ -18,5 +18,5 @@ int foo(const struct XX* r) {
return 1;
}
/* { dg-final { scan-tree-dump-times "&" 0 "forwprop2" } } */
/* { dg-final { scan-tree-dump-times "= &" 0 "forwprop2" } } */
/* { dg-final { cleanup-tree-dump "forwprop2" } } */

2
gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-19.c
View File

@ -12,5 +12,5 @@ int g()
return *i; /* This should be turned into a.i */
}
/* { dg-final { scan-tree-dump "= a.i;" "ccp1" } } */
/* { dg-final { scan-tree-dump "= MEM\\\[\\\(int \\\*\\\)&a\\\];" "ccp1" } } */
/* { dg-final { cleanup-tree-dump "ccp1" } } */

11
gcc/tree-ssa-ccp.c
View File

@ -1182,6 +1182,17 @@ ccp_fold (gimple stmt)
TREE_CODE (rhs),
TREE_TYPE (rhs), val);
}
else if (TREE_CODE (rhs) == BIT_FIELD_REF
&& TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME)
{
tree val = get_constant_value (TREE_OPERAND (rhs, 0));
if (val)
return fold_ternary_loc (EXPR_LOCATION (rhs),
TREE_CODE (rhs),
TREE_TYPE (rhs), val,
TREE_OPERAND (rhs, 1),
TREE_OPERAND (rhs, 2));
}
else if (TREE_CODE (rhs) == MEM_REF
&& TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME)
{