* pa.h (ASM_OUTPUT_SECTION_NAME): Fix typo.

[pf3gnuchains/gcc-fork.git] / gcc / recog.c

diff --git a/gcc/recog.c b/gcc/recog.c
index 745d628..92fc6d8 100644 (file)
--- a/gcc/recog.c
+++ b/gcc/recog.c
@@ -1,5 +1,5 @@
 /* Subroutines used by or related to instruction recognition.
-   Copyright (C) 1987, 88, 91, 92, 93, 1994 Free Software Foundation, Inc.
+   Copyright (C) 1987, 1988, 1991-6, 1997 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -374,15 +374,28 @@ validate_replace_rtx_1 (loc, from, to, object)
        }
     }
 
+  /* Note that if CODE's RTX_CLASS is "c" or "<" we will have already
+     done the substitution, otherwise we won't.  */
+
   switch (code)
     {
     case PLUS:
       /* If we have have a PLUS whose second operand is now a CONST_INT, use
         plus_constant to try to simplify it.  */
       if (GET_CODE (XEXP (x, 1)) == CONST_INT && XEXP (x, 1) == to)
-       validate_change (object, loc, 
-                        plus_constant (XEXP (x, 0), INTVAL (XEXP (x, 1))), 1);
+       validate_change (object, loc, plus_constant (XEXP (x, 0), INTVAL (to)),
+                        1);
       return;
+
+    case MINUS:
+      if (GET_CODE (to) == CONST_INT && XEXP (x, 1) == from)
+       {
+         validate_change (object, loc,
+                          plus_constant (XEXP (x, 0), - INTVAL (to)),
+                          1);
+         return;
+       }
+      break;
       
     case ZERO_EXTEND:
     case SIGN_EXTEND:
@@ -871,7 +884,9 @@ register_operand (op, mode)
          && TEST_HARD_REG_BIT (reg_class_contents[(int) CLASS_CANNOT_CHANGE_SIZE],
                                REGNO (SUBREG_REG (op)))
          && (GET_MODE_SIZE (mode)
-             != GET_MODE_SIZE (GET_MODE (SUBREG_REG (op)))))
+             != GET_MODE_SIZE (GET_MODE (SUBREG_REG (op))))
+         && GET_MODE_CLASS (GET_MODE (SUBREG_REG (op))) != MODE_COMPLEX_INT
+         && GET_MODE_CLASS (GET_MODE (SUBREG_REG (op))) != MODE_COMPLEX_FLOAT)
        return 0;
 #endif
 
@@ -1650,6 +1665,11 @@ constrain_operands (insn_code_num, strict)
 
          earlyclobber[opno] = 0;
 
+         /* A unary operator may be accepted by the predicate, but it
+            is irrelevant for matching contraints.  */
+         if (GET_RTX_CLASS (GET_CODE (op)) == '1')
+           op = XEXP (op, 0);
+
          if (GET_CODE (op) == SUBREG)
            {
              if (GET_CODE (SUBREG_REG (op)) == REG
@@ -1765,8 +1785,9 @@ constrain_operands (insn_code_num, strict)
                break;
 
              case 'X':
-               /* This is used for a MATCH_SCRATCH in the cases when we
-                  don't actually need anything.  So anything goes any time. */
+               /* This is used for a MATCH_SCRATCH in the cases when
+                  we don't actually need anything.  So anything goes
+                  any time.  */
                win = 1;
                break;
 
@@ -1862,7 +1883,12 @@ constrain_operands (insn_code_num, strict)
 
              case 'V':
                if (GET_CODE (op) == MEM
-                   && ! offsettable_memref_p (op))
+                   && ((strict > 0 && ! offsettable_memref_p (op))
+                       || (strict < 0
+                           && !(CONSTANT_P (op) || GET_CODE (op) == MEM))
+                       || (reload_in_progress
+                           && !(GET_CODE (op) == REG
+                                && REGNO (op) >= FIRST_PSEUDO_REGISTER))))
                  win = 1;
                break;
 
@@ -1916,8 +1942,8 @@ constrain_operands (insn_code_num, strict)
                  if ((GET_CODE (recog_operand[opno]) == MEM
                       || op_types[opno] != OP_OUT)
                      && opno != eopno
-                     /* Ignore things like match_operator operands. */
-                     && *constraints[opno] != 0
+                     /* Ignore things like match_operator operands.  */
+                     && *insn_operand_constraint[insn_code_num][opno] != 0
                      && ! (matching_operands[opno] == eopno
                            && rtx_equal_p (recog_operand[opno],
                                            recog_operand[eopno]))