[patch match.pd c c++]: Ignore results of 'shorten_compare' and move missing patterns in match.pd

Kai Tietz ktietz70@googlemail.com
Fri Sep 11 08:15:00 GMT 2015


Ping.

2015-09-08 13:17 GMT+02:00 Kai Tietz <ktietz70@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  <ktietz@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  <ktietz@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" } } */



More information about the Gcc-patches mailing list