* pa.md (dbra pattern): Use output_dbra.

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

diff --git a/gcc/recog.c b/gcc/recog.c
index b9fcdbe..2232db2 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, 1988, 1991 Free Software Foundation, Inc.
+   Copyright (C) 1987, 1988, 1991, 1992, 1993 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -96,7 +96,7 @@ recog_memoized (insn)
      rtx insn;
 {
   if (INSN_CODE (insn) < 0)
-    INSN_CODE (insn) = recog (PATTERN (insn), insn, 0);
+    INSN_CODE (insn) = recog (PATTERN (insn), insn, NULL_PTR);
   return INSN_CODE (insn);
 }
 \f
@@ -117,7 +117,7 @@ check_asm_operands (x)
     return 1;
 
   operands = (rtx *) alloca (noperands * sizeof (rtx));
-  decode_asm_operands (x, operands, 0, 0, 0);
+  decode_asm_operands (x, operands, NULL_PTR, NULL_PTR, NULL_PTR);
 
   for (i = 0; i < noperands; i++)
     if (!general_operand (operands[i], VOIDmode))
@@ -389,7 +389,7 @@ validate_replace_rtx_1 (loc, from, to, object)
         of the operand.  If we are replacing the operand with a VOIDmode
         constant, we lose the information.  So try to simplify the operation
         in that case.  If it fails, substitute in something that we know
-        won't be recogized.  */
+        won't be recognized.  */
       if (GET_MODE (to) == VOIDmode
          && (XEXP (x, 0) == from
              || (GET_CODE (XEXP (x, 0)) == REG && GET_CODE (from) == REG
@@ -465,7 +465,7 @@ validate_replace_rtx_1 (loc, from, to, object)
            wanted_mode = insn_operand_mode[(int) CODE_FOR_extv][1];
 #endif
 
-         /* If we have a narrower mode, we can do someting.  */
+         /* If we have a narrower mode, we can do something.  */
          if (wanted_mode != VOIDmode
              && GET_MODE_SIZE (wanted_mode) < GET_MODE_SIZE (is_mode))
            {
@@ -487,8 +487,7 @@ validate_replace_rtx_1 (loc, from, to, object)
              MEM_VOLATILE_P (newmem) = MEM_VOLATILE_P (to);
              MEM_IN_STRUCT_P (newmem) = MEM_IN_STRUCT_P (to);
 
-             validate_change (object, &XEXP (x, 2),
-                              gen_rtx (CONST_INT, VOIDmode, pos), 1);
+             validate_change (object, &XEXP (x, 2), GEN_INT (pos), 1);
              validate_change (object, &XEXP (x, 0), newmem, 1);
            }
        }
@@ -745,7 +744,7 @@ find_single_use (dest, insn, ploc)
    The main use of this function is as a predicate in match_operand
    expressions in the machine description.
 
-   For an explaination of this function's behavior for registers of
+   For an explanation of this function's behavior for registers of
    class NO_REGS, see the comment for `register_operand'.  */
 
 int
@@ -762,7 +761,8 @@ general_operand (op, mode)
   /* Don't accept CONST_INT or anything similar
      if the caller wants something floating.  */
   if (GET_MODE (op) == VOIDmode && mode != VOIDmode
-      && GET_MODE_CLASS (mode) != MODE_INT)
+      && GET_MODE_CLASS (mode) != MODE_INT
+      && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
     return 0;
 
   if (CONSTANT_P (op))
@@ -902,7 +902,8 @@ immediate_operand (op, mode)
   /* Don't accept CONST_INT or anything similar
      if the caller wants something floating.  */
   if (GET_MODE (op) == VOIDmode && mode != VOIDmode
-      && GET_MODE_CLASS (mode) != MODE_INT)
+      && GET_MODE_CLASS (mode) != MODE_INT
+      && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
     return 0;
 
   return (CONSTANT_P (op)
@@ -935,7 +936,8 @@ const_double_operand (op, mode)
   /* Don't accept CONST_INT or anything similar
      if the caller wants something floating.  */
   if (GET_MODE (op) == VOIDmode && mode != VOIDmode
-      && GET_MODE_CLASS (mode) != MODE_INT)
+      && GET_MODE_CLASS (mode) != MODE_INT
+      && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
     return 0;
 
   return ((GET_CODE (op) == CONST_DOUBLE || GET_CODE (op) == CONST_INT)
@@ -965,7 +967,8 @@ nonmemory_operand (op, mode)
       /* Don't accept CONST_INT or anything similar
         if the caller wants something floating.  */
       if (GET_MODE (op) == VOIDmode && mode != VOIDmode
-         && GET_MODE_CLASS (mode) != MODE_INT)
+         && GET_MODE_CLASS (mode) != MODE_INT
+         && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
        return 0;
 
       return ((GET_MODE (op) == VOIDmode || GET_MODE (op) == mode)
@@ -1329,9 +1332,6 @@ decode_asm_operands (body, operands, operand_locs, constraints, modes)
   return template;
 }
 \f
-extern rtx plus_constant_for_output ();
-extern rtx copy_rtx ();
-
 /* Given an rtx *P, if it is a sum containing an integer constant term,
    return the location (type rtx *) of the pointer to that constant term.
    Otherwise, return a null pointer.  */
@@ -1726,6 +1726,8 @@ constrain_operands (insn_code_num, strict)
                if (strict < 0
                    || GENERAL_REGS == ALL_REGS
                    || GET_CODE (op) != REG
+                   || (reload_in_progress
+                       && REGNO (op) >= FIRST_PSEUDO_REGISTER)
                    || reg_fits_class_p (op, GENERAL_REGS, offset, mode))
                  win = 1;
                break;
@@ -1737,7 +1739,8 @@ constrain_operands (insn_code_num, strict)
                        && REGNO (op) >= FIRST_PSEUDO_REGISTER)
                    || (strict == 0 && GET_CODE (op) == SCRATCH)
                    || (GET_CODE (op) == REG
-                       && (GENERAL_REGS == ALL_REGS
+                       && ((GENERAL_REGS == ALL_REGS
+                            && REGNO (op) < FIRST_PSEUDO_REGISTER)
                            || reg_fits_class_p (op, GENERAL_REGS,
                                                 offset, mode))))
                  win = 1;
@@ -1752,7 +1755,10 @@ constrain_operands (insn_code_num, strict)
              case 'm':
                if (GET_CODE (op) == MEM
                    /* Before reload, accept what reload can turn into mem.  */
-                   || (strict < 0 && CONSTANT_P (op)))
+                   || (strict < 0 && CONSTANT_P (op))
+                   /* During reload, accept a pseudo  */
+                   || (reload_in_progress && GET_CODE (op) == REG
+                       && REGNO (op) >= FIRST_PSEUDO_REGISTER))
                  win = 1;
                break;
 
@@ -1774,7 +1780,7 @@ constrain_operands (insn_code_num, strict)
                /* Match any CONST_DOUBLE, but only if
                   we can examine the bits of it reliably.  */
                if ((HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
-                    || HOST_BITS_PER_INT != BITS_PER_WORD)
+                    || HOST_BITS_PER_WIDE_INT != BITS_PER_WORD)
                    && GET_MODE (op) != VOIDmode && ! flag_pretend_float)
                  break;
                if (GET_CODE (op) == CONST_DOUBLE)
@@ -1845,7 +1851,10 @@ constrain_operands (insn_code_num, strict)
                    || (strict == 0 && offsettable_nonstrict_memref_p (op))
                    /* Before reload, accept what reload can handle.  */
                    || (strict < 0
-                       && (CONSTANT_P (op) || GET_CODE (op) == MEM)))
+                       && (CONSTANT_P (op) || GET_CODE (op) == MEM))
+                   /* During reload, accept a pseudo  */
+                   || (reload_in_progress && GET_CODE (op) == REG
+                       && REGNO (op) >= FIRST_PSEUDO_REGISTER))
                  win = 1;
                break;
 
@@ -1887,7 +1896,8 @@ constrain_operands (insn_code_num, strict)
                  if ((GET_CODE (recog_operand[opno]) == MEM
                       || op_types[opno] != OP_OUT)
                      && opno != eopno
-                     && constraints[opno] != 0
+                     /* Ignore things like match_operator operands. */
+                     && *constraints[opno] != 0
                      && ! (matching_operands[opno] == eopno
                            && rtx_equal_p (recog_operand[opno],
                                            recog_operand[eopno]))