* combine.c (combine_simplify_rtx): Don't reverse condition

        if there is no reverse for the condition.
        (simplify_comparison): Don't simplify subregs from INT to FP.

        * gcc.c-torture/execute/ieee/fp-cmp-4.c (main): Make "data" static.
        * gcc.c-torture/execute/ieee/fp-cmp-5.c: New.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@45220 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 9a0eaa8..8b62604 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,5 +1,9 @@
 2001-08-27  Richard Henderson  <rth@redhat.com>
 
+       * combine.c (combine_simplify_rtx): Don't reverse condition
+       if there is no reverse for the condition.
+       (simplify_comparison): Don't simplify subregs from INT to FP.
+
        * config/m68k/m68k.md (sordered, sordered_1, sunordered, sunordered_1,
        suneq, suneq_1, sunge, sunge_1, sungt, sungt_1, sunle, sunle_1,
        sunlt, sunlt_1, sltgt, sltgt_1, fsogt_1, fsoge_1, fsolt_1, fsole_1,

diff --git a/gcc/combine.c b/gcc/combine.c
index d110284..78bf6ce 100644 (file)
--- a/gcc/combine.c
+++ b/gcc/combine.c
@@ -3636,7 +3636,8 @@ combine_simplify_rtx (x, op0_mode, last, in_dest)
                 just make the comparison operation.  */
              if (true_rtx == const_true_rtx && false_rtx == const0_rtx)
                x = gen_binary (cond_code, mode, cond, cop1);
-             else if (true_rtx == const0_rtx && false_rtx == const_true_rtx)
+             else if (true_rtx == const0_rtx && false_rtx == const_true_rtx
+                      && reverse_condition (cond_code) != UNKNOWN)
                x = gen_binary (reverse_condition (cond_code),
                                mode, cond, cop1);
 
@@ -10828,6 +10829,7 @@ simplify_comparison (code, pop0, pop1)
 
   if (GET_CODE (op0) == SUBREG && subreg_lowpart_p (op0)
       && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
+      && GET_MODE_CLASS (GET_MODE (SUBREG_REG (op0))) == MODE_INT
       && (code == NE || code == EQ)
       && ((GET_MODE_SIZE (GET_MODE (op0))
           > GET_MODE_SIZE (GET_MODE (SUBREG_REG (op0))))))
@@ -10838,6 +10840,7 @@ simplify_comparison (code, pop0, pop1)
 
   else if (GET_CODE (op0) == SUBREG && subreg_lowpart_p (op0)
           && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
+          && GET_MODE_CLASS (GET_MODE (SUBREG_REG (op0))) == MODE_INT
           && (code == NE || code == EQ)
           && (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (op0)))
               <= HOST_BITS_PER_WIDE_INT)

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 1bdaf96..31844aa 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2001-08-27  Richard Henderson  <rth@redhat.com>
+
+       * gcc.c-torture/execute/ieee/fp-cmp-4.c (main): Make "data" static.
+       * gcc.c-torture/execute/ieee/fp-cmp-5.c: New.
+
 2001-08-25  Aldy Hernandez  <aldyh@redhat.com>
 
         * gcc.dg/asm-names.c (ymain): New.

diff --git a/gcc/testsuite/gcc.c-torture/execute/ieee/fp-cmp-4.c b/gcc/testsuite/gcc.c-torture/execute/ieee/fp-cmp-4.c
index 80342ee..45527a2 100644 (file)
--- a/gcc/testsuite/gcc.c-torture/execute/ieee/fp-cmp-4.c
+++ b/gcc/testsuite/gcc.c-torture/execute/ieee/fp-cmp-4.c
@@ -104,7 +104,7 @@ main()
     unsigned lg : 1;
   };
 
-  const struct try data[] =
+  static struct try const data[] =
   {
     { NAN, NAN, 1, 0, 0, 0, 0, 0 },
     { 0.0, NAN, 1, 0, 0, 0, 0, 0 },

diff --git a/gcc/testsuite/gcc.c-torture/execute/ieee/fp-cmp-5.c b/gcc/testsuite/gcc.c-torture/execute/ieee/fp-cmp-5.c
new file mode 100644 (file)
index 0000000..9c70072
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/ieee/fp-cmp-5.c
@@ -0,0 +1,131 @@
+/* Like fp-cmp-4.c, but test that the setcc patterns are correct.  */
+
+static int
+test_isunordered(double x, double y)
+{
+  return __builtin_isunordered(x, y);
+}
+
+static int
+test_not_isunordered(double x, double y)
+{
+  return !__builtin_isunordered(x, y);
+}
+
+static int
+test_isless(double x, double y)
+{
+  return __builtin_isless(x, y);
+}
+
+static int
+test_not_isless(double x, double y)
+{
+  return !__builtin_isless(x, y);
+}
+
+static int
+test_islessequal(double x, double y)
+{
+  return __builtin_islessequal(x, y);
+}
+
+static int
+test_not_islessequal(double x, double y)
+{
+  return !__builtin_islessequal(x, y);
+}
+
+static int
+test_isgreater(double x, double y)
+{
+  return __builtin_isgreater(x, y);
+}
+
+static int
+test_not_isgreater(double x, double y)
+{
+  return !__builtin_isgreater(x, y);
+}
+
+static int
+test_isgreaterequal(double x, double y)
+{
+  return __builtin_isgreaterequal(x, y);
+}
+
+static int
+test_not_isgreaterequal(double x, double y)
+{
+  return !__builtin_isgreaterequal(x, y);
+}
+
+static int
+test_islessgreater(double x, double y)
+{
+  return __builtin_islessgreater(x, y);
+}
+
+static int
+test_not_islessgreater(double x, double y)
+{
+  return !__builtin_islessgreater(x, y);
+}
+
+static void
+one_test(double x, double y, int expected,
+         int (*pos) (double, double), int (*neg) (double, double))
+{
+  if ((*pos)(x, y) != expected)
+    abort ();
+  if ((*neg)(x, y) != !expected)
+    abort ();
+}
+
+#define NAN (0.0 / 0.0)
+
+int
+main()
+{
+  struct try
+  {
+    double x, y;
+    int result[6];
+  };
+
+  static struct try const data[] =
+  {
+    { NAN, NAN, { 1, 0, 0, 0, 0, 0 } },
+    { 0.0, NAN, { 1, 0, 0, 0, 0, 0 } },
+    { NAN, 0.0, { 1, 0, 0, 0, 0, 0 } },
+    { 0.0, 0.0, { 0, 0, 1, 0, 1, 0 } },
+    { 1.0, 2.0, { 0, 1, 1, 0, 0, 1 } },
+    { 2.0, 1.0, { 0, 0, 0, 1, 1, 1 } },
+  };
+
+  struct test
+  {
+    int (*pos)(double, double);
+    int (*neg)(double, double);
+  };
+
+  static struct test const tests[] =
+  {
+    { test_isunordered, test_not_isunordered },
+    { test_isless, test_not_isless },
+    { test_islessequal, test_not_islessequal },
+    { test_isgreater, test_not_isgreater },
+    { test_isgreaterequal, test_not_isgreaterequal },
+    { test_islessgreater, test_not_islessgreater }
+  };
+
+  const int n = sizeof(data) / sizeof(data[0]);
+  int i, j;
+
+  for (i = 0; i < n; ++i)
+    for (j = 0; j < 6; ++j)
+      one_test (data[i].x, data[i].y, data[i].result[j],
+               tests[j].pos, tests[j].neg);
+
+  exit (0);
+}