Ping. 2015-09-08 13:17 GMT+02:00 Kai Tietz <ktiet...@googlemail.com>: > Hi, > > This patch is the first part of obsoleting 'shorten_compare' function > for folding. > It adjusts the uses of 'shorten_compare' to ignore folding returned by > it, and adds > missing pattterns to match.pd to allow full bootstrap of C/C++ without > regressions. > Due we are using 'shorten_compare' for some diagnostic we can't simply > remove it. So if this patch gets approved, the next step will be to > rename the function to something like 'check_compare', and adjust its > arguments and inner logic to reflect that we don't modify > arguments/expression anymore within that function. > > Bootstrap just show 2 regressions within gcc.dg testsuite due patterns > matched are folded more early by forward-propagation. I adjusted > them, and added them to patch, too. > > I did regression-testing for x86_64-unknown-linux-gnu. > > ChangeLog > > 2015-09-08 Kai Tietz <kti...@redhat.com> > > * match.pd: Add missing patterns from shorten_compare. > * c/c-typeck.c (build_binary_op): Discard foldings of shorten_compare. > * cp/typeck.c (cp_build_binary_op): Likewise. > > 2015-09-08 Kai Tietz <kti...@redhat.com> > > * gcc.dg/tree-ssa/vrp23.c: Adjust testcase to reflect that > pattern is matching now already within forward-propagation pass. > * gcc.dg/tree-ssa/vrp24.c: Likewise. > > Index: match.pd > =================================================================== > --- match.pd (Revision 227528) > +++ match.pd (Arbeitskopie) > @@ -1786,6 +1786,45 @@ along with GCC; see the file COPYING3. If not see > (op (abs @0) zerop@1) > (op @0 @1))) > > +/* Simplify '((type) X) cmp ((type) Y' to shortest possible types, of X and > Y, > + if type's precision is wider then precision of X's and Y's type. > + Logic taken from shorten_compare function. */ > +(for op (tcc_comparison) > + (simplify > + (op (convert@0 @1) (convert@3 @2)) > + (if ((TREE_CODE (TREE_TYPE (@1)) == REAL_TYPE) > + == (TREE_CODE (TREE_TYPE (@2)) == REAL_TYPE) > + && (TREE_CODE (TREE_TYPE (@1)) == REAL_TYPE) > + == (TREE_CODE (TREE_TYPE (@0)) == REAL_TYPE) > + && single_use (@1) > + && single_use (@3) > + && TYPE_UNSIGNED (TREE_TYPE (@1)) == TYPE_UNSIGNED (TREE_TYPE (@2)) > + && !((TREE_CODE (TREE_TYPE (@1)) == REAL_TYPE > + && DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (@1)))) > + || (TREE_CODE (TREE_TYPE (@2)) == REAL_TYPE > + && DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (@2))))) > + && TYPE_PRECISION (TREE_TYPE (@1)) < TYPE_PRECISION (TREE_TYPE (@0)) > + && TYPE_PRECISION (TREE_TYPE (@2)) < TYPE_PRECISION (TREE_TYPE (@0)) > + ) > + (with { > + tree comtype = TYPE_PRECISION (TREE_TYPE (@1)) > + < TYPE_PRECISION (TREE_TYPE (@2)) ? TREE_TYPE (@2) > + : TREE_TYPE (@1); > + if (INTEGRAL_TYPE_P (TREE_TYPE (@0))) > + { > + if (TYPE_UNSIGNED (TREE_TYPE (@1)) || TYPE_UNSIGNED > (TREE_TYPE (@0))) > + comtype = unsigned_type_for (comtype); > + else > + comtype = signed_type_for (comtype); > + } > + } > + (op (convert:comtype @1) (convert:comtype @2)) > + ) > + ) > + ) > +) > + > + > /* From fold_sign_changed_comparison and fold_widened_comparison. */ > (for cmp (simple_comparison) > (simplify > @@ -2046,7 +2085,43 @@ along with GCC; see the file COPYING3. If not see > (if (cmp == LE_EXPR) > (ge (convert:st @0) { build_zero_cst (st); }) > (lt (convert:st @0) { build_zero_cst (st); })))))))))) > - > + > +/* Simplify '(type) X cmp CST' to 'X cmp (type-of-X) CST', if > + CST fits into the type of X. */ > +(for cmp (simple_comparison) > + (simplify > + (cmp (convert@2 @0) INTEGER_CST@1) > + (if (INTEGRAL_TYPE_P (TREE_TYPE (@0)) > + && TYPE_PRECISION (TREE_TYPE (@1)) > TYPE_PRECISION (TREE_TYPE (@0)) > + && single_use (@2) > + && (TYPE_UNSIGNED (TREE_TYPE (@0)) > + || TYPE_UNSIGNED (TREE_TYPE (@0)) == TYPE_UNSIGNED > (TREE_TYPE (@1)) > + || cmp == NE_EXPR || cmp == EQ_EXPR) > + && !POINTER_TYPE_P (TREE_TYPE (@0)) > + && int_fits_type_p (@1, TREE_TYPE (@0))) > + (with { tree optype = TREE_TYPE (@0); } > + (cmp @0 (convert:optype @1)) > + ) > + ) > + ) > +) > + > +/* See if '(type) X ==/!= CST' represents a condition, > + which is always true, or false due CST's value. */ > +(for cmp (ne eq) > + (simplify > + (cmp (convert@2 @0) INTEGER_CST@1) > + (if (INTEGRAL_TYPE_P (TREE_TYPE (@0)) > + && TYPE_PRECISION (TREE_TYPE (@1)) >= TYPE_PRECISION (TREE_TYPE > (@0)) > + && single_use (@2) > + && !POINTER_TYPE_P (TREE_TYPE (@0)) > + && !int_fits_type_p (@1, TREE_TYPE (@0)) > + && TYPE_UNSIGNED (TREE_TYPE (@0)) == TYPE_UNSIGNED (TREE_TYPE (@1))) > + { constant_boolean_node (cmp == NE_EXPR, type); } > + ) > + ) > +) > + > (for cmp (unordered ordered unlt unle ungt unge uneq ltgt) > /* If the second operand is NaN, the result is constant. */ > (simplify > Index: cp/typeck.c > =================================================================== > --- cp/typeck.c (Revision 227528) > +++ cp/typeck.c (Arbeitskopie) > @@ -5000,14 +5000,8 @@ cp_build_binary_op (location_t location, > pass the copies by reference, then copy them back afterward. */ > tree xop0 = op0, xop1 = op1, xresult_type = result_type; > enum tree_code xresultcode = resultcode; > - tree val > - = shorten_compare (location, &xop0, &xop1, &xresult_type, > - &xresultcode); > - if (val != 0) > - return cp_convert (boolean_type_node, val, complain); > - op0 = xop0, op1 = xop1; > - converted = 1; > - resultcode = xresultcode; > + shorten_compare (location, &xop0, &xop1, &xresult_type, > + &xresultcode); > } > > if ((short_compare || code == MIN_EXPR || code == MAX_EXPR) > Index: c/c-typeck.c > =================================================================== > --- c/c-typeck.c (Revision 227528) > +++ c/c-typeck.c (Arbeitskopie) > @@ -11193,20 +11193,9 @@ build_binary_op (location_t location, enum tree_co > pass the copies by reference, then copy them back afterward. */ > tree xop0 = op0, xop1 = op1, xresult_type = result_type; > enum tree_code xresultcode = resultcode; > - tree val > - = shorten_compare (location, &xop0, &xop1, &xresult_type, > - &xresultcode); > + shorten_compare (location, &xop0, &xop1, &xresult_type, > + &xresultcode); > > - if (val != 0) > - { > - ret = val; > - goto return_build_binary_op; > - } > - > - op0 = xop0, op1 = xop1; > - converted = 1; > - resultcode = xresultcode; > - > if (c_inhibit_evaluation_warnings == 0) > { > bool op0_maybe_const = true;
Make sure to split patch here. Above patch and this can't be applied together. > Index: gcc.dg/tree-ssa/vrp23.c > =================================================================== > --- gcc.dg/tree-ssa/vrp23.c (Revision 227528) > +++ gcc.dg/tree-ssa/vrp23.c (Arbeitskopie) > @@ -1,5 +1,5 @@ > /* { dg-do compile } */ > -/* { dg-options "-O2 -fdump-tree-vrp1-details" } */ > +/* { dg-options "-O2 -fdump-tree-vrp1-details -fdump-tree-forwprop1" } */ > > void aa (void); > void aos (void); > @@ -44,6 +44,10 @@ L8: > > /* The n_sets > 0 test can be simplified into n_sets == 1 since the > only way to reach the test is when n_sets <= 1, and the only value > - which satisfies both conditions is n_sets == 1. */ > -/* { dg-final { scan-tree-dump-times "Simplified relational" 1 "vrp1" } } */ > + which satisfies both conditions is n_sets == 1. > + We catch this pattern for this testcase already in forward-propagation > + pass, as use of n_sets becomes single one. Therefore we expect that > + vrp won't find this pattern anymore. */ > +/* { dg-final { scan-tree-dump-times "Simplified relational" 0 "vrp1" } } */ > +/* { dg-final { scan-tree-dump-times "Replaced" 3 "forwprop1" } } */ > > Index: gcc.dg/tree-ssa/vrp24.c > =================================================================== > --- gcc.dg/tree-ssa/vrp24.c (Revision 227528) > +++ gcc.dg/tree-ssa/vrp24.c (Arbeitskopie) > @@ -1,5 +1,5 @@ > /* { dg-do compile } */ > -/* { dg-options "-O2 -fdump-tree-vrp1-details" } */ > +/* { dg-options "-O2 -fdump-tree-vrp1-details -fdump-tree-forwprop1" } */ > > > struct rtx_def; > @@ -90,6 +90,9 @@ L7: > > The second n_sets > 0 test can also be simplified into n_sets == 1 > as the only way to reach the tests is when n_sets <= 1 and the only > - value which satisfies both conditions is n_sets == 1. */ > -/* { dg-final { scan-tree-dump-times "Simplified relational" 2 "vrp1" } } */ > + value which satisfies both conditions is n_sets == 1. > + We catch one of the simplifications already in forward-propagation pass. > + Therefore we exprect just one simplified relational detected > within vrp1. */ > +/* { dg-final { scan-tree-dump-times "Simplified relational" 1 "vrp1" } } */ > +/* { dg-final { scan-tree-dump-times "Replaced" 2 "forwprop1" } } */