*** empty log message ***

From-SVN: r1219

diff --git a/gcc/cse.c b/gcc/cse.c
index a54781e68e0f7882f410bcd353b7579cd8ac476c..d3a89d2fca91112fb28922a33d18a273cf00f31a 100644 (file)
--- a/gcc/cse.c
+++ b/gcc/cse.c
@@ -929,6 +929,20 @@ insert_regs (x, classp, modified)
          return 1;
        }
     }
+
+  /* If X is a SUBREG, we will likely be inserting the inner register in the
+     table.  If that register doesn't have an assigned quantity number at
+     this point but does later, the insertion that we will be doing now will
+     not be accessible because its hash code will have changed.  So assign
+     a quantity number now.  */
+
+  else if (GET_CODE (x) == SUBREG && GET_CODE (SUBREG_REG (x)) == REG
+          && ! REGNO_QTY_VALID_P (REGNO (SUBREG_REG (x))))
+    {
+      insert_regs (SUBREG_REG (x), 0, 0);
+      mention_regs (SUBREG_REG (x));
+      return 1;
+    }
   else
     return mention_regs (x);
 }
@@ -2549,9 +2563,23 @@ find_comparison_args (code, parg1, parg2)
 
       else if (GET_RTX_CLASS (GET_CODE (arg1)) == '<')
        {
-         if (code == NE || (code == LT && STORE_FLAG_VALUE == -1))
+         if (code == NE
+             || (GET_MODE_CLASS (GET_MODE (arg1)) == MODE_INT
+                 && code == LT && STORE_FLAG_VALUE == -1)
+#ifdef FLOAT_STORE_FLAG_VALUE
+             || (GET_MODE_CLASS (GET_MODE (arg1)) == MODE_FLOAT
+                 && FLOAT_STORE_FLAG_VALUE < 0)
+#endif
+             )
            x = arg1;
-         else if (code == EQ || (code == GE && STORE_FLAG_VALUE == -1))
+         else if (code == EQ
+                  || (GET_MODE_CLASS (GET_MODE (arg1)) == MODE_INT
+                      && code == GE && STORE_FLAG_VALUE == -1)
+#ifdef FLOAT_STORE_FLAG_VALUE
+                  || (GET_MODE_CLASS (GET_MODE (arg1)) == MODE_FLOAT
+                      && FLOAT_STORE_FLAG_VALUE < 0)
+#endif
+                  )
            x = arg1, reverse_code = 1;
        }
 
@@ -2586,10 +2614,16 @@ find_comparison_args (code, parg1, parg2)
                 for STORE_FLAG_VALUE, also look at LT and GE operations.  */
              || ((code == NE
                   || (code == LT
-                      && inner_mode != VOIDmode
+                      && GET_MODE_CLASS (inner_mode) == MODE_INT
                       && GET_MODE_BITSIZE (inner_mode) <= HOST_BITS_PER_INT
                       && (STORE_FLAG_VALUE
-                          & (1 << (GET_MODE_BITSIZE (inner_mode) - 1)))))
+                          & (1 << (GET_MODE_BITSIZE (inner_mode) - 1))))
+#ifdef FLOAT_STORE_FLAG_VALUE
+                  || (code == LT
+                      && GET_MODE_CLASS (inner_mode) == MODE_FLOAT
+                      && FLOAT_STORE_FLAG_VALUE < 0)
+#endif
+                  )
                  && GET_RTX_CLASS (GET_CODE (p->exp)) == '<'))
            {
              x = p->exp;
@@ -2597,10 +2631,16 @@ find_comparison_args (code, parg1, parg2)
            }
          else if ((code == EQ
                    || (code == GE
-                       && inner_mode != VOIDmode
+                       && GET_MODE_CLASS (inner_mode) == MODE_INT
                        && GET_MODE_BITSIZE (inner_mode) <= HOST_BITS_PER_INT
                        && (STORE_FLAG_VALUE
-                           & (1 << (GET_MODE_BITSIZE (inner_mode) - 1)))))
+                           & (1 << (GET_MODE_BITSIZE (inner_mode) - 1))))
+#ifdef FLOAT_STORE_FLAG_VALUE
+                   || (code == GE
+                       && GET_MODE_CLASS (inner_mode) == MODE_FLOAT
+                       && FLOAT_STORE_FLAG_VALUE < 0)
+#endif
+                   )
                   && GET_RTX_CLASS (GET_CODE (p->exp)) == '<')
            {
              reverse_code = 1;
@@ -4175,11 +4215,9 @@ fold_rtx (x, insn)
       break;
 
     case SUBREG:
-      /* If this is a single word of a multi-word value, see if we previously
-        assigned a value to that word.  */
-      if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD
-         && GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))) > UNITS_PER_WORD
-         && (new = lookup_as_function (x, CONST_INT)) != 0)
+      /* See if we previously assigned a constant value to this SUBREG.  */
+      if ((new = lookup_as_function (x, CONST_INT)) != 0
+         || (new = lookup_as_function (x, CONST_DOUBLE)) != 0)
        return new;
 
       /* If this is a paradoxical SUBREG, we can't do anything with
@@ -4598,6 +4636,15 @@ fold_rtx (x, insn)
       if (const_arg0 == 0 || const_arg1 == 0)
        {
          struct table_elt *p0, *p1;
+         rtx true = const_true_rtx, false = const0_rtx;
+
+#ifdef FLOAT_STORE_FLAG_VALUE
+         if (GET_MODE_CLASS (mode))
+           {
+             true = immed_real_const_1 (FLOAT_STORE_FLAG_VALUE, mode);
+             false = CONST0_RTX (mode);
+           }
+#endif
 
          code = find_comparison_args (code, &folded_arg0, &folded_arg1);
          const_arg0 = equiv_constant (folded_arg0);
@@ -4636,9 +4683,9 @@ fold_rtx (x, insn)
                      || GET_CODE (folded_arg0) == CONST))
                {
                  if (code == EQ)
-                   return const0_rtx;
+                   return false;
                  else if (code == NE)
-                   return const_true_rtx;
+                   return true;
                }
 
              /* See if the two operands are the same.  We don't do this
@@ -4661,7 +4708,7 @@ fold_rtx (x, insn)
                          && p0->first_same_value == p1->first_same_value)))
                return ((code == EQ || code == LE || code == GE
                         || code == LEU || code == GEU)
-                       ? const_true_rtx : const0_rtx);
+                       ? true : false);
 
              /* If FOLDED_ARG0 is a register, see if the comparison we are
                 doing now is either the same as we did before or the reverse
@@ -4684,7 +4731,7 @@ fold_rtx (x, insn)
                                  == qty_comparison_qty[qty]))))
                    return (comparison_dominates_p (qty_comparison_code[qty],
                                                    code)
-                           ? const_true_rtx : const0_rtx);
+                           ? true : false);
                }
            }
        }
@@ -4706,20 +4753,29 @@ fold_rtx (x, insn)
              int sign_bitnum = GET_MODE_BITSIZE (mode_arg0) - 1;
              int has_sign = (HOST_BITS_PER_INT >= sign_bitnum
                              && (INTVAL (inner_const) & (1 << sign_bitnum)));
+             rtx true = const_true_rtx, false = const0_rtx;
+
+#ifdef FLOAT_STORE_FLAG_VALUE
+             if (GET_MODE_CLASS (mode))
+               {
+                 true = immed_real_const_1 (FLOAT_STORE_FLAG_VALUE, mode);
+                 false = CONST0_RTX (mode);
+               }
+#endif
 
              switch (code)
                {
                case EQ:
-                 return const0_rtx;
+                 return false;
                case NE:
-                 return const_true_rtx;
+                 return true;
                case LT:  case LE:
                  if (has_sign)
-                   return const_true_rtx;
+                   return true;
                  break;
                case GT:  case GE:
                  if (has_sign)
-                   return const0_rtx;
+                   return false;
                  break;
                }
            }
@@ -4728,6 +4784,11 @@ fold_rtx (x, insn)
       new = simplify_relational_operation (code, mode_arg0,
                                           const_arg0 ? const_arg0 : folded_arg0,
                                           const_arg1 ? const_arg1 : folded_arg1);
+#ifdef FLOAT_STORE_FLAG_VALUE
+      if (new != 0 && GET_MODE_CLASS (mode) == MODE_FLOAT)
+       new = ((new == const0_rtx) ? CONST0_RTX (mode)
+              : immed_real_const_1 (FLOAT_STORE_FLAG_VALUE, mode));
+#endif
       break;
 
     case '2':
@@ -6323,7 +6384,7 @@ cse_insn (insn, in_libcall_block)
        if (GET_CODE (dest) == STRICT_LOW_PART)
          dest = SUBREG_REG (XEXP (dest, 0));
 
-       if (GET_CODE (dest) == REG)
+       if (GET_CODE (dest) == REG || GET_CODE (dest) == SUBREG)
          /* Registers must also be inserted into chains for quantities.  */
          if (insert_regs (dest, sets[i].src_elt, 1))
            /* If `insert_regs' changes something, the hash code must be