tree.def (UNNE_EXPR): Remove.

        * tree.def (UNNE_EXPR): Remove.
        * c-typeck.c (build_binary_op): Don't handle it.
        * expr.c (expand_expr, do_jump, do_store_flag): Likewise.
        * cp/typeck.c (build_binary_op_nodefault): Likewise.

        * rtl.def (UNNE): Remove.
        (LTGT): Add.
        * jump.c (reverse_condition): Update accordingly.
        (swap_condition): Likewise.
        (comparison_dominates_p): Handle unordered comparisons.
        (reverse_condition_maybe_unordered): New.
        * rtl.h (reverse_condition_maybe_unordered): Declare.

        * sparc.c (select_cc_mode): Update for UNNE/LTGT.
        (output_cbranch): Use reverse_condition_maybe_unordered and LTGT.
        * sparc.h (REVERSIBLE_CC_MODE): Always true.  Update docs.
        * sparc.md (bltgt): New.

From-SVN: r31624

1 files changed, 78 insertions, 12 deletions

diff --git a/gcc/jump.c b/gcc/jump.c
index bd22231..26cc011 100644
--- a/gcc/jump.c
+++ b/gcc/jump.c
@@ -3473,7 +3473,7 @@ reverse_condition (code)
     case UNGT:
     case UNGE:
     case UNEQ:
-    case UNNE:
+    case LTGT:
       return UNKNOWN;
 
     default:
@@ -3481,6 +3481,62 @@ reverse_condition (code)
     }
 }
 
+/* Similar, but we're allowed to generate unordered comparisons, which
+   makes it safe for IEEE floating-point.  Of course, we have to recognize
+   that the target will support them too...  */
+
+enum rtx_code
+reverse_condition_maybe_unordered (code)
+     enum rtx_code code;
+{
+  /* Non-IEEE formats don't have unordered conditions.  */
+  if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT)
+    return reverse_condition (code);
+
+  switch (code)
+    {
+    case EQ:
+      return NE;
+    case NE:
+      return EQ;
+    case GT:
+      return UNLE;
+    case GE:
+      return UNLT;
+    case LT:
+      return UNGE;
+    case LE:
+      return UNGT;
+    case LTGT:
+      return UNEQ;
+    case GTU:
+      return LEU;
+    case GEU:
+      return LTU;
+    case LTU:
+      return GEU;
+    case LEU:
+      return GTU;
+    case UNORDERED:
+      return ORDERED;
+    case ORDERED:
+      return UNORDERED;
+    case UNLT:
+      return GE;
+    case UNLE:
+      return GT;
+    case UNGT:
+      return LE;
+    case UNGE:
+      return LT;
+    case UNEQ:
+      return LTGT;
+
+    default:
+      abort ();
+    }
+}
+
 /* Similar, but return the code when two operands of a comparison are swapped.
    This IS safe for IEEE floating-point.  */
 
@@ -3495,7 +3551,7 @@ swap_condition (code)
     case UNORDERED:
     case ORDERED:
     case UNEQ:
-    case UNNE:
+    case LTGT:
       return code;
 
     case GT:
@@ -3514,7 +3570,6 @@ swap_condition (code)
       return GTU;
     case LEU:
       return GEU;
-
     case UNLT:
       return UNGT;
     case UNLE:
@@ -3549,13 +3604,10 @@ unsigned_condition (code)
 
     case GT:
       return GTU;
-
     case GE:
       return GEU;
-
     case LT:
       return LTU;
-
     case LE:
       return LEU;
 
@@ -3582,13 +3634,10 @@ signed_condition (code)
 
     case GTU:
       return GT;
-
     case GEU:
       return GE;
-
     case LTU:
       return LT;
-
     case LEU:
       return LE;
 
@@ -3610,17 +3659,29 @@ comparison_dominates_p (code1, code2)
   switch (code1)
     {
     case EQ:
-      if (code2 == LE || code2 == LEU || code2 == GE || code2 == GEU)
+      if (code2 == LE || code2 == LEU || code2 == GE || code2 == GEU
+	  || code2 == ORDERED)
 	return 1;
       break;
 
     case LT:
-      if (code2 == LE || code2 == NE)
+      if (code2 == LE || code2 == NE || code2 == ORDERED)
 	return 1;
       break;
 
     case GT:
-      if (code2 == GE || code2 == NE)
+      if (code2 == GE || code2 == NE || code2 == ORDERED)
+	return 1;
+      break;
+
+    case GE:
+    case LE:
+      if (code2 == ORDERED)
+	return 1;
+      break;
+
+    case LTGT:
+      if (code2 == NE || code2 == ORDERED)
 	return 1;
       break;
 
@@ -3633,6 +3694,11 @@ comparison_dominates_p (code1, code2)
       if (code2 == GEU || code2 == NE)
 	return 1;
       break;
+
+    case UNORDERED:
+      if (code2 == NE)
+	return 1;
+      break;
       
     default:
       break;