Index: 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" } } */