Hello,
these are just a few tweaks / clean-ups. The 'ord' pattern is the dual of
the 'unord' one I added last month. The tree_unary_nonnegative_warnv_p
change should have no effect (it is only used from VRP which does not
handle vectors (yet?)) but it seems right to handle vectors like scalars
here.
Regtested on ppc64le-redhat-linux.
2015-05-15 Marc Glisse <marc.gli...@inria.fr>
PR tree-optimization/63387
gcc/
* match.pd ((X /[ex] A) * A -> X): Remove unnecessary condition.
((x ord x) & (y ord y) -> (x ord y),
(x ord x) & (x ord y) -> (x ord y)): New simplifications.
* fold-const.c (tree_unary_nonnegative_warnv_p) <ABS_EXPR>: Handle
vectors like scalars.
gcc/testsuite/
* gcc.dg/pr63387-2.c: New testcase.
--
Marc GlisseIndex: gcc/fold-const.c
===================================================================
--- gcc/fold-const.c (revision 223214)
+++ gcc/fold-const.c (working copy)
@@ -14685,21 +14685,21 @@ tree_unary_nonnegative_warnv_p (enum tre
bool *strict_overflow_p)
{
if (TYPE_UNSIGNED (type))
return true;
switch (code)
{
case ABS_EXPR:
/* We can't return 1 if flag_wrapv is set because
ABS_EXPR<INT_MIN> = INT_MIN. */
- if (!INTEGRAL_TYPE_P (type))
+ if (!ANY_INTEGRAL_TYPE_P (type))
return true;
if (TYPE_OVERFLOW_UNDEFINED (type))
{
*strict_overflow_p = true;
return true;
}
break;
case NON_LVALUE_EXPR:
case FLOAT_EXPR:
Index: gcc/match.pd
===================================================================
--- gcc/match.pd (revision 223214)
+++ gcc/match.pd (working copy)
@@ -791,22 +791,21 @@ along with GCC; see the file COPYING3.
&& TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (@0))
&& operand_equal_p (@1, build_low_bits_mask (TREE_TYPE (@1),
TYPE_PRECISION (type)), 0))
(convert @0)))
/* (X /[ex] A) * A -> X. */
(simplify
(mult (convert? (exact_div @0 @1)) @1)
/* Look through a sign-changing conversion. */
- (if (TYPE_PRECISION (TREE_TYPE (@0)) == TYPE_PRECISION (type))
- (convert @0)))
+ (convert @0))
/* Canonicalization of binary operations. */
/* Convert X + -C into X - C. */
(simplify
(plus @0 REAL_CST@1)
(if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (@1)))
(with { tree tem = fold_unary (NEGATE_EXPR, type, @1); }
(if (!TREE_OVERFLOW (tem) || !flag_trapping_math)
(minus @0 { tem; })))))
@@ -944,22 +943,29 @@ along with GCC; see the file COPYING3.
(icmp @0 @1))
(if (ic == ncmp)
(ncmp @0 @1)))))
/* Unordered tests if either argument is a NaN. */
(simplify
(bit_ior (unordered @0 @0) (unordered @1 @1))
(if (types_match (@0, @1))
(unordered @0 @1)))
(simplify
+ (bit_and (ordered @0 @0) (ordered @1 @1))
+ (if (types_match (@0, @1))
+ (ordered @0 @1)))
+(simplify
(bit_ior:c (unordered @0 @0) (unordered:c@2 @0 @1))
@2)
+(simplify
+ (bit_and:c (ordered @0 @0) (ordered:c@2 @0 @1))
+ @2)
/* Simplification of math builtins. */
(define_operator_list LOG BUILT_IN_LOGF BUILT_IN_LOG BUILT_IN_LOGL)
(define_operator_list EXP BUILT_IN_EXPF BUILT_IN_EXP BUILT_IN_EXPL)
(define_operator_list LOG2 BUILT_IN_LOG2F BUILT_IN_LOG2 BUILT_IN_LOG2L)
(define_operator_list EXP2 BUILT_IN_EXP2F BUILT_IN_EXP2 BUILT_IN_EXP2L)
(define_operator_list LOG10 BUILT_IN_LOG10F BUILT_IN_LOG10 BUILT_IN_LOG10L)
(define_operator_list EXP10 BUILT_IN_EXP10F BUILT_IN_EXP10 BUILT_IN_EXP10L)
(define_operator_list POW BUILT_IN_POWF BUILT_IN_POW BUILT_IN_POWL)
Index: gcc/testsuite/gcc.dg/pr63387-2.c
===================================================================
--- gcc/testsuite/gcc.dg/pr63387-2.c (revision 0)
+++ gcc/testsuite/gcc.dg/pr63387-2.c (working copy)
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-optimized" } */
+
+int f(double aaa, double bbb){
+ int xa = !__builtin_isunordered(aaa, aaa);
+ int xb = !__builtin_isunordered(bbb, bbb);
+ return xa & xb;
+}
+
+int g(double aaa, double bbb){
+ int xa = !__builtin_isunordered(aaa, bbb);
+ int xb = !__builtin_isunordered(bbb, bbb);
+ return xa & xb;
+}
+
+int h(double ccc, float ddd){
+ int xc = !__builtin_isunordered(ccc, ccc);
+ int xd = !__builtin_isunordered(ddd, ddd);
+ return xc & xd;
+}
+
+/* { dg-final { scan-tree-dump-not "aaa\[^\n\r\]* ord aaa" "optimized" } } */
+/* { dg-final { scan-tree-dump-not "bbb\[^\n\r\]* ord bbb" "optimized" } } */
+/* { dg-final { scan-tree-dump-times "aaa\[^\n\r\]* ord bbb" 2 "optimized" } }
*/
+/* { dg-final { scan-tree-dump-not "ccc\[^\n\r\]* ord ddd" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
