re PR middle-end/17024 (ICE in fold_cond_expr_with_comparison, at fold-const.c:4324)

	PR middle-end/17024
	* fold-const.c (fold_cond_expr_with_comparison): Handle unordered
	floating point comparison operators.  Change aborts to gcc_asserts.

	* gcc.dg/pr17024-1.c: New test case.

From-SVN: r87339

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index f5d0a00e487cbf9105341f7429d198bf9df61ee0..ab280adb6477380e7f4e241cf412c47bc8353a95 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,9 @@
+2004-09-10  Roger Sayle  <roger@eyesopen.com>
+
+       PR middle-end/17024
+       * fold-const.c (fold_cond_expr_with_comparison): Handle unordered
+       floating point comparison operators.  Change aborts to gcc_asserts.
+
 2004-09-10  Geoffrey Keating  <geoffk@apple.com>
 
        * final.c (output_asm_insn): Correct problem with -fverbose-asm.

diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 10cdb69b4874f7136cbd5903f32eac56bf22fd0b..d0720e9f0239d08e07f195dd68bde5782e700c66 100644 (file)
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -4162,10 +4162,17 @@ fold_cond_expr_with_comparison (tree type, tree arg0, tree arg1, tree arg2)
     switch (comp_code)
       {
       case EQ_EXPR:
+      case UNEQ_EXPR:
        tem = fold_convert (arg1_type, arg1);
        return pedantic_non_lvalue (fold_convert (type, negate_expr (tem)));
       case NE_EXPR:
+      case LTGT_EXPR:
        return pedantic_non_lvalue (fold_convert (type, arg1));
+      case UNGE_EXPR:
+      case UNGT_EXPR:
+       if (flag_trapping_math)
+         break;
+       /* Fall through.  */
       case GE_EXPR:
       case GT_EXPR:
        if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
@@ -4173,6 +4180,10 @@ fold_cond_expr_with_comparison (tree type, tree arg0, tree arg1, tree arg2)
                               (TREE_TYPE (arg1)), arg1);
        tem = fold (build1 (ABS_EXPR, TREE_TYPE (arg1), arg1));
        return pedantic_non_lvalue (fold_convert (type, tem));
+      case UNLE_EXPR:
+      case UNLT_EXPR:
+       if (flag_trapping_math)
+         break;
       case LE_EXPR:
       case LT_EXPR:
        if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
@@ -4181,7 +4192,8 @@ fold_cond_expr_with_comparison (tree type, tree arg0, tree arg1, tree arg2)
        tem = fold (build1 (ABS_EXPR, TREE_TYPE (arg1), arg1));
        return negate_expr (fold_convert (type, tem));
       default:
-       gcc_unreachable ();
+       gcc_assert (TREE_CODE_CLASS (comp_code) == '<');
+       break;
       }
 
   /* A != 0 ? A : 0 is simply A, unless A is -0.  Likewise
@@ -4245,6 +4257,8 @@ fold_cond_expr_with_comparison (tree type, tree arg0, tree arg1, tree arg2)
          return pedantic_non_lvalue (fold_convert (type, arg1));
        case LE_EXPR:
        case LT_EXPR:
+       case UNLE_EXPR:
+       case UNLT_EXPR:
          /* In C++ a ?: expression can be an lvalue, so put the
             operand which will be used if they are equal first
             so that we can convert this back to the
@@ -4253,31 +4267,37 @@ fold_cond_expr_with_comparison (tree type, tree arg0, tree arg1, tree arg2)
            {
              comp_op0 = fold_convert (comp_type, comp_op0);
              comp_op1 = fold_convert (comp_type, comp_op1);
-             tem = fold (build2 (MIN_EXPR, comp_type,
-                                 (comp_code == LE_EXPR
-                                  ? comp_op0 : comp_op1),
-                                 (comp_code == LE_EXPR
-                                  ? comp_op1 : comp_op0)));
+             tem = (comp_code == LE_EXPR || comp_code == UNLE_EXPR)
+                   ? fold (build2 (MIN_EXPR, comp_type, comp_op0, comp_op1))
+                   : fold (build2 (MIN_EXPR, comp_type, comp_op1, comp_op0));
              return pedantic_non_lvalue (fold_convert (type, tem));
            }
          break;
        case GE_EXPR:
        case GT_EXPR:
+       case UNGE_EXPR:
+       case UNGT_EXPR:
          if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
            {
              comp_op0 = fold_convert (comp_type, comp_op0);
              comp_op1 = fold_convert (comp_type, comp_op1);
-             tem = fold (build2 (MAX_EXPR, comp_type,
-                                 (comp_code == GE_EXPR
-                                  ? comp_op0 : comp_op1),
-                                 (comp_code == GE_EXPR
-                                  ? comp_op1 : comp_op0)));
-             tem = fold (build2 (MAX_EXPR, comp_type, comp_op0, comp_op1));
+             tem = (comp_code == GE_EXPR || comp_code == UNGE_EXPR)
+                   ? fold (build2 (MAX_EXPR, comp_type, comp_op0, comp_op1))
+                   : fold (build2 (MAX_EXPR, comp_type, comp_op1, comp_op0));
              return pedantic_non_lvalue (fold_convert (type, tem));
            }
          break;
+       case UNEQ_EXPR:
+         if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
+           return pedantic_non_lvalue (fold_convert (type, arg2));
+         break;
+       case LTGT_EXPR:
+         if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
+           return pedantic_non_lvalue (fold_convert (type, arg1));
+         break;
        default:
-         gcc_unreachable ();
+         gcc_assert (TREE_CODE_CLASS (comp_code) == '<');
+         break;
        }
     }
 

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 3d052a9aae665fd4cb9b7ae65264d43e10674d7b..d899403219e6da8def3de78ff016a94f66a2a9bb 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2004-09-10  Roger Sayle  <roger@eyesopen.com>
+
+       PR middle-end/17024
+       * gcc.dg/pr17024-1.c: New test case.
+
 2004-09-10  Eric Christopher  <echristo@redhat.com>
 
        * gcc.dg/20040910-1.c: New test.

diff --git a/gcc/testsuite/gcc.dg/pr17024-1.c b/gcc/testsuite/gcc.dg/pr17024-1.c
new file mode 100644 (file)
index 0000000..d8bdf01
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr17024-1.c
@@ -0,0 +1,15 @@
+/* PR middle-end/17024 */
+/* { dg-do compile } */
+/* { dg-options "-funsafe-math-optimizations" } */
+
+#define MAX2(a,b) (((a)>(b)) ? (a) : (b))
+
+void C(double);
+
+void i(int k)
+{
+       double c[1];
+       C(MAX2(0.,c[k]));
+       return;
+}
+