git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

(aff_combination_expand): Move (T1)(X *+- CST) simplification to ... 

(tree_to_aff_combination): ... here.

From-SVN: r248955
This commit is contained in:
Bin Cheng 2017-06-07 10:46:21 +00:00 committed by Bin Cheng
parent c18101f5d1
commit 1b92ccde2c
2 changed files with 36 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
gcc/ChangeLog
View File

@ -1,3 +1,8 @@
2017-06-07 Bin Cheng <bin.cheng@arm.com>
(aff_combination_expand): Move (T1)(X *+- CST) simplification to ...
(tree_to_aff_combination): ... here.
2017-06-07 Bin Cheng <bin.cheng@arm.com> 2017-06-07 Bin Cheng <bin.cheng@arm.com>
* tree-ssa-loop-ivopts.c (ivopts_estimate_reg_pressure): New * tree-ssa-loop-ivopts.c (ivopts_estimate_reg_pressure): New

53
gcc/tree-affine.c
View File

@ -363,6 +363,33 @@ tree_to_aff_combination (tree expr, tree type, aff_tree *comb)
aff_combination_add (comb, &tmp); aff_combination_add (comb, &tmp);
return; return;
CASE_CONVERT:
{
tree otype = TREE_TYPE (expr);
tree inner = TREE_OPERAND (expr, 0);
tree itype = TREE_TYPE (inner);
enum tree_code icode = TREE_CODE (inner);
/* In principle this is a valid folding, but it isn't necessarily
an optimization, so do it here and not in fold_unary. */
if ((icode == PLUS_EXPR || icode == MINUS_EXPR || icode == MULT_EXPR)
&& TREE_CODE (itype) == INTEGER_TYPE
&& TREE_CODE (otype) == INTEGER_TYPE
&& TYPE_PRECISION (otype) > TYPE_PRECISION (itype)
&& TYPE_OVERFLOW_UNDEFINED (itype)
&& TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST)
{
/* Convert (T1)(X *+- CST) into (T1)X *+- (T1)CST if X's type has
undefined overflow behavior. */
tree op0 = fold_convert (otype, TREE_OPERAND (inner, 0));
tree op1 = fold_convert (otype, TREE_OPERAND (inner, 1));
expr = fold_build2 (icode, otype, op0, op1);
tree_to_aff_combination (expr, type, comb);
return;
}
}
break;
default: default:
break; break;
} }
@ -639,28 +666,10 @@ aff_combination_expand (aff_tree *comb ATTRIBUTE_UNUSED,
exp = XNEW (struct name_expansion); exp = XNEW (struct name_expansion);
exp->in_progress = 1; exp->in_progress = 1;
*slot = exp; *slot = exp;
/* In principle this is a generally valid folding, but rhs = gimple_assign_rhs_to_tree (def);
it is not unconditionally an optimization, so do it if (e != name)
here and not in fold_unary. */ rhs = fold_convert (type, rhs);
/* Convert (T1)(X *+- CST) into (T1)X *+- (T1)CST if T1 is wider
than the type of X and overflow for the type of X is
undefined. */
if (e != name
&& INTEGRAL_TYPE_P (type)
&& INTEGRAL_TYPE_P (TREE_TYPE (name))
&& TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (name))
&& TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (name))
&& (code == PLUS_EXPR || code == MINUS_EXPR || code == MULT_EXPR)
&& TREE_CODE (gimple_assign_rhs2 (def)) == INTEGER_CST)
rhs = fold_build2 (code, type,
fold_convert (type, gimple_assign_rhs1 (def)),
fold_convert (type, gimple_assign_rhs2 (def)));
else
{
rhs = gimple_assign_rhs_to_tree (def);
if (e != name)
rhs = fold_convert (type, rhs);
}
tree_to_aff_combination_expand (rhs, comb->type, &current, cache); tree_to_aff_combination_expand (rhs, comb->type, &current, cache);
exp->expansion = current; exp->expansion = current;
exp->in_progress = 0; exp->in_progress = 0;