PR optimization/13424 (hppa), bootstrap/14462, c/14828

[pf3gnuchains/gcc-fork.git] / gcc / reload.c
diff --git a/gcc/reload.c b/gcc/reload.c

index 9b8cdc9..f1682f7 100644 (file)
--- a/gcc/reload.c
+++ b/gcc/reload.c
@@ -1,6 +1,6 @@
  /* Search an insn for pseudo regs that must be in hard regs and are not.
     Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
  /* Search an insn for pseudo regs that must be in hard regs and are not.
     Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-   1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+   1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
  
  This file is part of GCC.
  
  
  This file is part of GCC.
  
@@ -88,6 +88,8 @@ a register with any other reload.  */
  
  #include "config.h"
  #include "system.h"
  
  #include "config.h"
  #include "system.h"
+#include "coretypes.h"
+#include "tm.h"
  #include "rtl.h"
  #include "tm_p.h"
  #include "insn-config.h"
  #include "rtl.h"
  #include "tm_p.h"
  #include "insn-config.h"
@@ -102,10 +104,8 @@ a register with any other reload.  */
  #include "output.h"
  #include "function.h"
  #include "toplev.h"
  #include "output.h"
  #include "function.h"
  #include "toplev.h"
-
-#ifndef REGISTER_MOVE_COST
-#define REGISTER_MOVE_COST(m, x, y) 2
-#endif
+#include "params.h"
+#include "target.h"
  
  #ifndef REGNO_MODE_OK_FOR_BASE_P
  #define REGNO_MODE_OK_FOR_BASE_P(REGNO, MODE) REGNO_OK_FOR_BASE_P (REGNO)
  
  #ifndef REGNO_MODE_OK_FOR_BASE_P
  #define REGNO_MODE_OK_FOR_BASE_P(REGNO, MODE) REGNO_OK_FOR_BASE_P (REGNO)
@@ -114,6 +114,12 @@ a register with any other reload.  */
  #ifndef REG_MODE_OK_FOR_BASE_P
  #define REG_MODE_OK_FOR_BASE_P(REGNO, MODE) REG_OK_FOR_BASE_P (REGNO)
  #endif
  #ifndef REG_MODE_OK_FOR_BASE_P
  #define REG_MODE_OK_FOR_BASE_P(REGNO, MODE) REG_OK_FOR_BASE_P (REGNO)
  #endif
+
+/* True if X is a constant that can be forced into the constant pool.  */
+#define CONST_POOL_OK_P(X)                     \
+  (CONSTANT_P (X)                              \
+   && GET_CODE (X) != HIGH                     \
+   && !targetm.cannot_force_const_mem (X))
  \f
  /* All reloads of the current insn are recorded here.  See reload.h for
     comments.  */
  \f
  /* All reloads of the current insn are recorded here.  See reload.h for
     comments.  */
@@ -174,6 +180,7 @@ struct decomposition
  
  static rtx secondary_memlocs[NUM_MACHINE_MODES];
  static rtx secondary_memlocs_elim[NUM_MACHINE_MODES][MAX_RECOG_OPERANDS];
  
  static rtx secondary_memlocs[NUM_MACHINE_MODES];
  static rtx secondary_memlocs_elim[NUM_MACHINE_MODES][MAX_RECOG_OPERANDS];
+static int secondary_memlocs_elim_used = 0;
  #endif
  
  /* The instruction we are doing reloads for;
  #endif
  
  /* The instruction we are doing reloads for;
@@ -236,44 +243,46 @@ static int output_reloadnum;
        : (type)))
  
  #ifdef HAVE_SECONDARY_RELOADS
        : (type)))
  
  #ifdef HAVE_SECONDARY_RELOADS
-static int push_secondary_reload PARAMS ((int, rtx, int, int, enum reg_class,
-                                       enum machine_mode, enum reload_type,
-                                       enum insn_code *));
+static int push_secondary_reload (int, rtx, int, int, enum reg_class,
+                                 enum machine_mode, enum reload_type,
+                                 enum insn_code *);
  #endif
  #endif
-static enum reg_class find_valid_class PARAMS ((enum machine_mode, int));
-static int reload_inner_reg_of_subreg PARAMS ((rtx, enum machine_mode));
-static void push_replacement   PARAMS ((rtx *, int, enum machine_mode));
-static void combine_reloads    PARAMS ((void));
-static int find_reusable_reload        PARAMS ((rtx *, rtx, enum reg_class,
-                                      enum reload_type, int, int));
-static rtx find_dummy_reload   PARAMS ((rtx, rtx, rtx *, rtx *,
-                                      enum machine_mode, enum machine_mode,
-                                      enum reg_class, int, int));
-static int hard_reg_set_here_p PARAMS ((unsigned int, unsigned int, rtx));
-static struct decomposition decompose PARAMS ((rtx));
-static int immune_p            PARAMS ((rtx, rtx, struct decomposition));
-static int alternative_allows_memconst PARAMS ((const char *, int));
-static rtx find_reloads_toplev PARAMS ((rtx, int, enum reload_type, int,
-                                        int, rtx, int *));
-static rtx make_memloc         PARAMS ((rtx, int));
-static int find_reloads_address        PARAMS ((enum machine_mode, rtx *, rtx, rtx *,
-                                      int, enum reload_type, int, rtx));
-static rtx subst_reg_equivs    PARAMS ((rtx, rtx));
-static rtx subst_indexed_address PARAMS ((rtx));
-static void update_auto_inc_notes PARAMS ((rtx, int, int));
-static int find_reloads_address_1 PARAMS ((enum machine_mode, rtx, int, rtx *,
-                                        int, enum reload_type,int, rtx));
-static void find_reloads_address_part PARAMS ((rtx, rtx *, enum reg_class,
-                                            enum machine_mode, int,
-                                            enum reload_type, int));
-static rtx find_reloads_subreg_address PARAMS ((rtx, int, int, enum reload_type,
-                                             int, rtx));
-static int find_inc_amount     PARAMS ((rtx, rtx));
+static enum reg_class find_valid_class (enum machine_mode, int, unsigned int);
+static int reload_inner_reg_of_subreg (rtx, enum machine_mode, int);
+static void push_replacement (rtx *, int, enum machine_mode);
+static void dup_replacements (rtx *, rtx *);
+static void combine_reloads (void);
+static int find_reusable_reload (rtx *, rtx, enum reg_class,
+                                enum reload_type, int, int);
+static rtx find_dummy_reload (rtx, rtx, rtx *, rtx *, enum machine_mode,
+                             enum machine_mode, enum reg_class, int, int);
+static int hard_reg_set_here_p (unsigned int, unsigned int, rtx);
+static struct decomposition decompose (rtx);
+static int immune_p (rtx, rtx, struct decomposition);
+static int alternative_allows_memconst (const char *, int);
+static rtx find_reloads_toplev (rtx, int, enum reload_type, int, int, rtx,
+                               int *);
+static rtx make_memloc (rtx, int);
+static int maybe_memory_address_p (enum machine_mode, rtx, rtx *);
+static int find_reloads_address (enum machine_mode, rtx *, rtx, rtx *,
+                                int, enum reload_type, int, rtx);
+static rtx subst_reg_equivs (rtx, rtx);
+static rtx subst_indexed_address (rtx);
+static void update_auto_inc_notes (rtx, int, int);
+static int find_reloads_address_1 (enum machine_mode, rtx, int, rtx *,
+                                  int, enum reload_type,int, rtx);
+static void find_reloads_address_part (rtx, rtx *, enum reg_class,
+                                      enum machine_mode, int,
+                                      enum reload_type, int);
+static rtx find_reloads_subreg_address (rtx, int, int, enum reload_type,
+                                       int, rtx);
+static void copy_replacements_1 (rtx *, rtx *, int);
+static int find_inc_amount (rtx, rtx);
  \f
  #ifdef HAVE_SECONDARY_RELOADS
  
  /* Determine if any secondary reloads are needed for loading (if IN_P is
  \f
  #ifdef HAVE_SECONDARY_RELOADS
  
  /* Determine if any secondary reloads are needed for loading (if IN_P is
-   non-zero) or storing (if IN_P is zero) X to or from a reload register of
+   nonzero) or storing (if IN_P is zero) X to or from a reload register of
     register class RELOAD_CLASS in mode RELOAD_MODE.  If secondary reloads
     are needed, push them.
  
     register class RELOAD_CLASS in mode RELOAD_MODE.  If secondary reloads
     are needed, push them.
  
@@ -282,16 +291,10 @@ static int find_inc_amount        PARAMS ((rtx, rtx));
     need a secondary reload.  */
  
  static int
     need a secondary reload.  */
  
  static int
-push_secondary_reload (in_p, x, opnum, optional, reload_class, reload_mode,
-                      type, picode)
-     int in_p;
-     rtx x;
-     int opnum;
-     int optional;
-     enum reg_class reload_class;
-     enum machine_mode reload_mode;
-     enum reload_type type;
-     enum insn_code *picode;
+push_secondary_reload (int in_p, rtx x, int opnum, int optional,
+                      enum reg_class reload_class,
+                      enum machine_mode reload_mode, enum reload_type type,
+                      enum insn_code *picode)
  {
    enum reg_class class = NO_REGS;
    enum machine_mode mode = reload_mode;
  {
    enum reg_class class = NO_REGS;
    enum machine_mode mode = reload_mode;
@@ -365,7 +368,7 @@ push_secondary_reload (in_p, x, opnum, optional, reload_class, reload_mode,
  
    if (icode != CODE_FOR_nothing)
      {
  
    if (icode != CODE_FOR_nothing)
      {
-      /* If IN_P is non-zero, the reload register will be the output in
+      /* If IN_P is nonzero, the reload register will be the output in
          operand 0.  If IN_P is zero, the reload register will be the input
          in operand 1.  Outputs should have an initial "=", which we must
          skip.  */
          operand 0.  If IN_P is zero, the reload register will be the input
          in operand 1.  Outputs should have an initial "=", which we must
          skip.  */
@@ -376,11 +379,13 @@ push_secondary_reload (in_p, x, opnum, optional, reload_class, reload_mode,
         insn_class = ALL_REGS;
        else
         {
         insn_class = ALL_REGS;
        else
         {
-         char insn_letter
-           = insn_data[(int) icode].operand[!in_p].constraint[in_p];
+         const char *insn_constraint
+           = &insn_data[(int) icode].operand[!in_p].constraint[in_p];
+         char insn_letter = *insn_constraint;
           insn_class
             = (insn_letter == 'r' ? GENERAL_REGS
           insn_class
             = (insn_letter == 'r' ? GENERAL_REGS
-              : REG_CLASS_FROM_LETTER ((unsigned char) insn_letter));
+              : REG_CLASS_FROM_CONSTRAINT ((unsigned char) insn_letter,
+                                           insn_constraint));
  
            if (insn_class == NO_REGS)
             abort ();
  
            if (insn_class == NO_REGS)
             abort ();
@@ -398,11 +403,14 @@ push_secondary_reload (in_p, x, opnum, optional, reload_class, reload_mode,
         mode = insn_data[(int) icode].operand[2].mode;
        else
         {
         mode = insn_data[(int) icode].operand[2].mode;
        else
         {
-         char t_letter = insn_data[(int) icode].operand[2].constraint[2];
+         const char *t_constraint
+           = &insn_data[(int) icode].operand[2].constraint[2];
+         char t_letter = *t_constraint;
           class = insn_class;
           t_mode = insn_data[(int) icode].operand[2].mode;
           t_class = (t_letter == 'r' ? GENERAL_REGS
           class = insn_class;
           t_mode = insn_data[(int) icode].operand[2].mode;
           t_class = (t_letter == 'r' ? GENERAL_REGS
-                    : REG_CLASS_FROM_LETTER ((unsigned char) t_letter));
+                    : REG_CLASS_FROM_CONSTRAINT ((unsigned char) t_letter,
+                                                 t_constraint));
           t_icode = icode;
           icode = CODE_FOR_nothing;
         }
           t_icode = icode;
           icode = CODE_FOR_nothing;
         }
@@ -581,11 +589,8 @@ push_secondary_reload (in_p, x, opnum, optional, reload_class, reload_mode,
     call find_reloads_address on the location being returned.  */
  
  rtx
     call find_reloads_address on the location being returned.  */
  
  rtx
-get_secondary_mem (x, mode, opnum, type)
-     rtx x ATTRIBUTE_UNUSED;
-     enum machine_mode mode;
-     int opnum;
-     enum reload_type type;
+get_secondary_mem (rtx x ATTRIBUTE_UNUSED, enum machine_mode mode,
+                  int opnum, enum reload_type type)
  {
    rtx loc;
    int mem_valid;
  {
    rtx loc;
    int mem_valid;
@@ -642,35 +647,40 @@ get_secondary_mem (x, mode, opnum, type)
                : type == RELOAD_FOR_OUTPUT ? RELOAD_FOR_OUTPUT_ADDRESS
                : RELOAD_OTHER);
  
                : type == RELOAD_FOR_OUTPUT ? RELOAD_FOR_OUTPUT_ADDRESS
                : RELOAD_OTHER);
  
-      find_reloads_address (mode, (rtx*) 0, XEXP (loc, 0), &XEXP (loc, 0),
+      find_reloads_address (mode, &loc, XEXP (loc, 0), &XEXP (loc, 0),
                             opnum, type, 0, 0);
      }
  
    secondary_memlocs_elim[(int) mode][opnum] = loc;
                             opnum, type, 0, 0);
      }
  
    secondary_memlocs_elim[(int) mode][opnum] = loc;
+  if (secondary_memlocs_elim_used <= (int)mode)
+    secondary_memlocs_elim_used = (int)mode + 1;
    return loc;
  }
  
  /* Clear any secondary memory locations we've made.  */
  
  void
    return loc;
  }
  
  /* Clear any secondary memory locations we've made.  */
  
  void
-clear_secondary_mem ()
+clear_secondary_mem (void)
  {
  {
-  memset ((char *) secondary_memlocs, 0, sizeof secondary_memlocs);
+  memset (secondary_memlocs, 0, sizeof secondary_memlocs);
  }
  #endif /* SECONDARY_MEMORY_NEEDED */
  \f
  /* Find the largest class for which every register number plus N is valid in
  }
  #endif /* SECONDARY_MEMORY_NEEDED */
  \f
  /* Find the largest class for which every register number plus N is valid in
-   M1 (if in range).  Abort if no such class exists.  */
+   M1 (if in range) and is cheap to move into REGNO.
+   Abort if no such class exists.  */
  
  static enum reg_class
  
  static enum reg_class
-find_valid_class (m1, n)
-     enum machine_mode m1 ATTRIBUTE_UNUSED;
-     int n;
+find_valid_class (enum machine_mode m1 ATTRIBUTE_UNUSED, int n,
+                 unsigned int dest_regno ATTRIBUTE_UNUSED)
  {
  {
+  int best_cost = -1;
    int class;
    int regno;
    enum reg_class best_class = NO_REGS;
    int class;
    int regno;
    enum reg_class best_class = NO_REGS;
+  enum reg_class dest_class ATTRIBUTE_UNUSED = REGNO_REG_CLASS (dest_regno);
    unsigned int best_size = 0;
    unsigned int best_size = 0;
+  int cost;
  
    for (class = 1; class < N_REG_CLASSES; class++)
      {
  
    for (class = 1; class < N_REG_CLASSES; class++)
      {
@@ -681,8 +691,18 @@ find_valid_class (m1, n)
             && ! HARD_REGNO_MODE_OK (regno + n, m1))
           bad = 1;
  
             && ! HARD_REGNO_MODE_OK (regno + n, m1))
           bad = 1;
  
-      if (! bad && reg_class_size[class] > best_size)
-       best_class = class, best_size = reg_class_size[class];
+      if (bad)
+       continue;
+      cost = REGISTER_MOVE_COST (m1, class, dest_class);
+
+      if ((reg_class_size[class] > best_size
+          && (best_cost < 0 || best_cost >= cost))
+         || best_cost > cost)
+       {
+         best_class = class;
+         best_size = reg_class_size[class];
+         best_cost = REGISTER_MOVE_COST (m1, class, dest_class);
+       }
      }
  
    if (best_size == 0)
      }
  
    if (best_size == 0)
@@ -700,11 +720,8 @@ find_valid_class (m1, n)
     DONT_SHARE is nonzero if we can't share any input-only reload for IN.  */
  
  static int
     DONT_SHARE is nonzero if we can't share any input-only reload for IN.  */
  
  static int
-find_reusable_reload (p_in, out, class, type, opnum, dont_share)
-     rtx *p_in, out;
-     enum reg_class class;
-     enum reload_type type;
-     int opnum, dont_share;
+find_reusable_reload (rtx *p_in, rtx out, enum reg_class class,
+                     enum reload_type type, int opnum, int dont_share)
  {
    rtx in = *p_in;
    int i;
  {
    rtx in = *p_in;
    int i;
@@ -754,10 +771,10 @@ find_reusable_reload (p_in, out, class, type, opnum, dont_share)
                                   true_regnum (rld[i].reg_rtx)))
         && out == 0 && rld[i].out == 0 && rld[i].in != 0
         && ((GET_CODE (in) == REG
                                   true_regnum (rld[i].reg_rtx)))
         && out == 0 && rld[i].out == 0 && rld[i].in != 0
         && ((GET_CODE (in) == REG
-            && GET_RTX_CLASS (GET_CODE (rld[i].in)) == 'a'
+            && GET_RTX_CLASS (GET_CODE (rld[i].in)) == RTX_AUTOINC
              && MATCHES (XEXP (rld[i].in, 0), in))
             || (GET_CODE (rld[i].in) == REG
              && MATCHES (XEXP (rld[i].in, 0), in))
             || (GET_CODE (rld[i].in) == REG
-               && GET_RTX_CLASS (GET_CODE (in)) == 'a'
+               && GET_RTX_CLASS (GET_CODE (in)) == RTX_AUTOINC
                 && MATCHES (XEXP (in, 0), rld[i].in)))
         && (rld[i].out == 0 || ! earlyclobber_operand_p (rld[i].out))
         && (reg_class_size[(int) class] == 1 || SMALL_REGISTER_CLASSES)
                 && MATCHES (XEXP (in, 0), rld[i].in)))
         && (rld[i].out == 0 || ! earlyclobber_operand_p (rld[i].out))
         && (reg_class_size[(int) class] == 1 || SMALL_REGISTER_CLASSES)
@@ -777,9 +794,7 @@ find_reusable_reload (p_in, out, class, type, opnum, dont_share)
     SUBREG_REG expression.  */
  
  static int
     SUBREG_REG expression.  */
  
  static int
-reload_inner_reg_of_subreg (x, mode)
-     rtx x;
-     enum machine_mode mode;
+reload_inner_reg_of_subreg (rtx x, enum machine_mode mode, int output)
  {
    rtx inner;
  
  {
    rtx inner;
  
@@ -807,9 +822,60 @@ reload_inner_reg_of_subreg (x, mode)
       word and the number of regs for INNER is not the same as the
       number of words in INNER, then INNER will need reloading.  */
    return (GET_MODE_SIZE (mode) <= UNITS_PER_WORD
       word and the number of regs for INNER is not the same as the
       number of words in INNER, then INNER will need reloading.  */
    return (GET_MODE_SIZE (mode) <= UNITS_PER_WORD
+         && output
           && GET_MODE_SIZE (GET_MODE (inner)) > UNITS_PER_WORD
           && ((GET_MODE_SIZE (GET_MODE (inner)) / UNITS_PER_WORD)
           && GET_MODE_SIZE (GET_MODE (inner)) > UNITS_PER_WORD
           && ((GET_MODE_SIZE (GET_MODE (inner)) / UNITS_PER_WORD)
-             != HARD_REGNO_NREGS (REGNO (inner), GET_MODE (inner))));
+             != (int) hard_regno_nregs[REGNO (inner)][GET_MODE (inner)]));
+}
+
+/* Return nonzero if IN can be reloaded into REGNO with mode MODE without
+   requiring an extra reload register.  The caller has already found that
+   IN contains some reference to REGNO, so check that we can produce the
+   new value in a single step.  E.g. if we have
+   (set (reg r13) (plus (reg r13) (const int 1))), and there is an
+   instruction that adds one to a register, this should succeed.
+   However, if we have something like
+   (set (reg r13) (plus (reg r13) (const int 999))), and the constant 999
+   needs to be loaded into a register first, we need a separate reload
+   register.
+   Such PLUS reloads are generated by find_reload_address_part.
+   The out-of-range PLUS expressions are usually introduced in the instruction
+   patterns by register elimination and substituting pseudos without a home
+   by their function-invariant equivalences.  */
+static int
+can_reload_into (rtx in, int regno, enum machine_mode mode)
+{
+  rtx dst, test_insn;
+  int r = 0;
+  struct recog_data save_recog_data;
+
+  /* For matching constraints, we often get notional input reloads where
+     we want to use the original register as the reload register.  I.e.
+     technically this is a non-optional input-output reload, but IN is
+     already a valid register, and has been chosen as the reload register.
+     Speed this up, since it trivially works.  */
+  if (GET_CODE (in) == REG)
+    return 1;
+
+  /* To test MEMs properly, we'd have to take into account all the reloads
+     that are already scheduled, which can become quite complicated.
+     And since we've already handled address reloads for this MEM, it
+     should always succeed anyway.  */
+  if (GET_CODE (in) == MEM)
+    return 1;
+
+  /* If we can make a simple SET insn that does the job, everything should
+     be fine.  */
+  dst =  gen_rtx_REG (mode, regno);
+  test_insn = make_insn_raw (gen_rtx_SET (VOIDmode, dst, in));
+  save_recog_data = recog_data;
+  if (recog_memoized (test_insn) >= 0)
+    {
+      extract_insn (test_insn);
+      r = constrain_operands (1);
+    }
+  recog_data = save_recog_data;
+  return r;
  }
  
  /* Record one reload that needs to be performed.
  }
  
  /* Record one reload that needs to be performed.
@@ -818,7 +884,7 @@ reload_inner_reg_of_subreg (x, mode)
     (IN is zero for data not read, and OUT is zero for data not written.)
     INLOC and OUTLOC point to the places in the instructions where
     IN and OUT were found.
     (IN is zero for data not read, and OUT is zero for data not written.)
     INLOC and OUTLOC point to the places in the instructions where
     IN and OUT were found.
-   If IN and OUT are both non-zero, it means the same register must be used
+   If IN and OUT are both nonzero, it means the same register must be used
     to reload both IN and OUT.
  
     CLASS is a register class required for the reloaded data.
     to reload both IN and OUT.
  
     CLASS is a register class required for the reloaded data.
@@ -846,16 +912,10 @@ reload_inner_reg_of_subreg (x, mode)
     distinguish them.  */
  
  int
     distinguish them.  */
  
  int
-push_reload (in, out, inloc, outloc, class,
-            inmode, outmode, strict_low, optional, opnum, type)
-     rtx in, out;
-     rtx *inloc, *outloc;
-     enum reg_class class;
-     enum machine_mode inmode, outmode;
-     int strict_low;
-     int optional;
-     int opnum;
-     enum reload_type type;
+push_reload (rtx in, rtx out, rtx *inloc, rtx *outloc,
+            enum reg_class class, enum machine_mode inmode,
+            enum machine_mode outmode, int strict_low, int optional,
+            int opnum, enum reload_type type)
  {
    int i;
    int dont_share = 0;
  {
    int i;
    int dont_share = 0;
@@ -947,9 +1007,8 @@ push_reload (in, out, inloc, outloc, class,
  
    if (in != 0 && GET_CODE (in) == SUBREG
        && (subreg_lowpart_p (in) || strict_low)
  
    if (in != 0 && GET_CODE (in) == SUBREG
        && (subreg_lowpart_p (in) || strict_low)
-#ifdef CLASS_CANNOT_CHANGE_MODE
-      && (class != CLASS_CANNOT_CHANGE_MODE
-         || ! CLASS_CANNOT_CHANGE_MODE_P (GET_MODE (SUBREG_REG (in)), inmode))
+#ifdef CANNOT_CHANGE_MODE_CLASS
+      && !CANNOT_CHANGE_MODE_CLASS (GET_MODE (SUBREG_REG (in)), inmode, class)
  #endif
        && (CONSTANT_P (SUBREG_REG (in))
           || GET_CODE (SUBREG_REG (in)) == PLUS
  #endif
        && (CONSTANT_P (SUBREG_REG (in))
           || GET_CODE (SUBREG_REG (in)) == PLUS
@@ -986,8 +1045,8 @@ push_reload (in, out, inloc, outloc, class,
                        > UNITS_PER_WORD)
                    && ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
                         / UNITS_PER_WORD)
                        > UNITS_PER_WORD)
                    && ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
                         / UNITS_PER_WORD)
-                      != HARD_REGNO_NREGS (REGNO (SUBREG_REG (in)),
-                                           GET_MODE (SUBREG_REG (in)))))
+                      != (int) hard_regno_nregs[REGNO (SUBREG_REG (in))]
+                                               [GET_MODE (SUBREG_REG (in))]))
                   || ! HARD_REGNO_MODE_OK (subreg_regno (in), inmode)))
  #ifdef SECONDARY_INPUT_RELOAD_CLASS
           || (SECONDARY_INPUT_RELOAD_CLASS (class, inmode, in) != NO_REGS
                   || ! HARD_REGNO_MODE_OK (subreg_regno (in), inmode)))
  #ifdef SECONDARY_INPUT_RELOAD_CLASS
           || (SECONDARY_INPUT_RELOAD_CLASS (class, inmode, in) != NO_REGS
@@ -996,14 +1055,11 @@ push_reload (in, out, inloc, outloc, class,
                                                 SUBREG_REG (in))
                   == NO_REGS))
  #endif
                                                 SUBREG_REG (in))
                   == NO_REGS))
  #endif
-#ifdef CLASS_CANNOT_CHANGE_MODE
+#ifdef CANNOT_CHANGE_MODE_CLASS
           || (GET_CODE (SUBREG_REG (in)) == REG
               && REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER
           || (GET_CODE (SUBREG_REG (in)) == REG
               && REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER
-             && (TEST_HARD_REG_BIT
-                 (reg_class_contents[(int) CLASS_CANNOT_CHANGE_MODE],
-                  REGNO (SUBREG_REG (in))))
-             && CLASS_CANNOT_CHANGE_MODE_P (GET_MODE (SUBREG_REG (in)),
-                                            inmode))
+             && REG_CANNOT_CHANGE_MODE_P
+             (REGNO (SUBREG_REG (in)), GET_MODE (SUBREG_REG (in)), inmode))
  #endif
           ))
      {
  #endif
           ))
      {
@@ -1030,7 +1086,7 @@ push_reload (in, out, inloc, outloc, class,
    /* Similar issue for (SUBREG constant ...) if it was not handled by the
       code above.  This can happen if SUBREG_BYTE != 0.  */
  
    /* Similar issue for (SUBREG constant ...) if it was not handled by the
       code above.  This can happen if SUBREG_BYTE != 0.  */
  
-  if (in != 0 && reload_inner_reg_of_subreg (in, inmode))
+  if (in != 0 && reload_inner_reg_of_subreg (in, inmode, 0))
      {
        enum reg_class in_class = class;
  
      {
        enum reg_class in_class = class;
  
@@ -1040,7 +1096,8 @@ push_reload (in, out, inloc, outloc, class,
                               subreg_regno_offset (REGNO (SUBREG_REG (in)),
                                                    GET_MODE (SUBREG_REG (in)),
                                                    SUBREG_BYTE (in),
                               subreg_regno_offset (REGNO (SUBREG_REG (in)),
                                                    GET_MODE (SUBREG_REG (in)),
                                                    SUBREG_BYTE (in),
-                                                  GET_MODE (in)));
+                                                  GET_MODE (in)),
+                             REGNO (SUBREG_REG (in)));
  
        /* This relies on the fact that emit_reload_insns outputs the
          instructions for input reloads of type RELOAD_OTHER in the same
  
        /* This relies on the fact that emit_reload_insns outputs the
          instructions for input reloads of type RELOAD_OTHER in the same
@@ -1060,10 +1117,8 @@ push_reload (in, out, inloc, outloc, class,
       and in that case the constraint should label it input-output.)  */
    if (out != 0 && GET_CODE (out) == SUBREG
        && (subreg_lowpart_p (out) || strict_low)
       and in that case the constraint should label it input-output.)  */
    if (out != 0 && GET_CODE (out) == SUBREG
        && (subreg_lowpart_p (out) || strict_low)
-#ifdef CLASS_CANNOT_CHANGE_MODE
-      && (class != CLASS_CANNOT_CHANGE_MODE
-         || ! CLASS_CANNOT_CHANGE_MODE_P (GET_MODE (SUBREG_REG (out)),
-                                          outmode))
+#ifdef CANNOT_CHANGE_MODE_CLASS
+      && !CANNOT_CHANGE_MODE_CLASS (GET_MODE (SUBREG_REG (out)), outmode, class)
  #endif
        && (CONSTANT_P (SUBREG_REG (out))
           || strict_low
  #endif
        && (CONSTANT_P (SUBREG_REG (out))
           || strict_low
@@ -1087,8 +1142,8 @@ push_reload (in, out, inloc, outloc, class,
                        > UNITS_PER_WORD)
                    && ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (out)))
                         / UNITS_PER_WORD)
                        > UNITS_PER_WORD)
                    && ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (out)))
                         / UNITS_PER_WORD)
-                      != HARD_REGNO_NREGS (REGNO (SUBREG_REG (out)),
-                                           GET_MODE (SUBREG_REG (out)))))
+                      != (int) hard_regno_nregs[REGNO (SUBREG_REG (out))]
+                                               [GET_MODE (SUBREG_REG (out))]))
                   || ! HARD_REGNO_MODE_OK (subreg_regno (out), outmode)))
  #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
           || (SECONDARY_OUTPUT_RELOAD_CLASS (class, outmode, out) != NO_REGS
                   || ! HARD_REGNO_MODE_OK (subreg_regno (out), outmode)))
  #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
           || (SECONDARY_OUTPUT_RELOAD_CLASS (class, outmode, out) != NO_REGS
@@ -1097,14 +1152,12 @@ push_reload (in, out, inloc, outloc, class,
                                                  SUBREG_REG (out))
                   == NO_REGS))
  #endif
                                                  SUBREG_REG (out))
                   == NO_REGS))
  #endif
-#ifdef CLASS_CANNOT_CHANGE_MODE
+#ifdef CANNOT_CHANGE_MODE_CLASS
           || (GET_CODE (SUBREG_REG (out)) == REG
               && REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER
           || (GET_CODE (SUBREG_REG (out)) == REG
               && REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER
-             && (TEST_HARD_REG_BIT
-                 (reg_class_contents[(int) CLASS_CANNOT_CHANGE_MODE],
-                  REGNO (SUBREG_REG (out))))
-             && CLASS_CANNOT_CHANGE_MODE_P (GET_MODE (SUBREG_REG (out)),
-                                            outmode))
+             && REG_CANNOT_CHANGE_MODE_P (REGNO (SUBREG_REG (out)),
+                                          GET_MODE (SUBREG_REG (out)),
+                                          outmode))
  #endif
           ))
      {
  #endif
           ))
      {
@@ -1126,7 +1179,7 @@ push_reload (in, out, inloc, outloc, class,
       However, we must reload the inner reg *as well as* the subreg in
       that case.  In this case, the inner reg is an in-out reload.  */
  
       However, we must reload the inner reg *as well as* the subreg in
       that case.  In this case, the inner reg is an in-out reload.  */
  
-  if (out != 0 && reload_inner_reg_of_subreg (out, outmode))
+  if (out != 0 && reload_inner_reg_of_subreg (out, outmode, 1))
      {
        /* This relies on the fact that emit_reload_insns outputs the
          instructions for output reloads of type RELOAD_OTHER in reverse
      {
        /* This relies on the fact that emit_reload_insns outputs the
          instructions for output reloads of type RELOAD_OTHER in reverse
@@ -1140,7 +1193,8 @@ push_reload (in, out, inloc, outloc, class,
                                      subreg_regno_offset (REGNO (SUBREG_REG (out)),
                                                           GET_MODE (SUBREG_REG (out)),
                                                           SUBREG_BYTE (out),
                                      subreg_regno_offset (REGNO (SUBREG_REG (out)),
                                                           GET_MODE (SUBREG_REG (out)),
                                                           SUBREG_BYTE (out),
-                                                         GET_MODE (out))),
+                                                         GET_MODE (out)),
+                                    REGNO (SUBREG_REG (out))),
                    VOIDmode, VOIDmode, 0, 0,
                    opnum, RELOAD_OTHER);
      }
                    VOIDmode, VOIDmode, 0, 0,
                    opnum, RELOAD_OTHER);
      }
@@ -1215,7 +1269,7 @@ push_reload (in, out, inloc, outloc, class,
         if (HARD_REGNO_MODE_OK (i, mode)
             && TEST_HARD_REG_BIT (reg_class_contents[(int) class], i))
           {
         if (HARD_REGNO_MODE_OK (i, mode)
             && TEST_HARD_REG_BIT (reg_class_contents[(int) class], i))
           {
-           int nregs = HARD_REGNO_NREGS (i, mode);
+           int nregs = hard_regno_nregs[i][mode];
  
             int j;
             for (j = 1; j < nregs; j++)
  
             int j;
             for (j = 1; j < nregs; j++)
@@ -1265,9 +1319,9 @@ push_reload (in, out, inloc, outloc, class,
  
  #ifdef SECONDARY_MEMORY_NEEDED
        /* If a memory location is needed for the copy, make one.  */
  
  #ifdef SECONDARY_MEMORY_NEEDED
        /* If a memory location is needed for the copy, make one.  */
-      if (in != 0 && GET_CODE (in) == REG
-         && REGNO (in) < FIRST_PSEUDO_REGISTER
-         && SECONDARY_MEMORY_NEEDED (REGNO_REG_CLASS (REGNO (in)),
+      if (in != 0 && (GET_CODE (in) == REG || GET_CODE (in) == SUBREG)
+         && reg_or_subregno (in) < FIRST_PSEUDO_REGISTER
+         && SECONDARY_MEMORY_NEEDED (REGNO_REG_CLASS (reg_or_subregno (in)),
                                       class, inmode))
         get_secondary_mem (in, inmode, opnum, type);
  #endif
                                       class, inmode))
         get_secondary_mem (in, inmode, opnum, type);
  #endif
@@ -1295,9 +1349,10 @@ push_reload (in, out, inloc, outloc, class,
        n_reloads++;
  
  #ifdef SECONDARY_MEMORY_NEEDED
        n_reloads++;
  
  #ifdef SECONDARY_MEMORY_NEEDED
-      if (out != 0 && GET_CODE (out) == REG
-         && REGNO (out) < FIRST_PSEUDO_REGISTER
-         && SECONDARY_MEMORY_NEEDED (class, REGNO_REG_CLASS (REGNO (out)),
+      if (out != 0 && (GET_CODE (out) == REG || GET_CODE (out) == SUBREG)
+         && reg_or_subregno (out) < FIRST_PSEUDO_REGISTER
+         && SECONDARY_MEMORY_NEEDED (class,
+                                     REGNO_REG_CLASS (reg_or_subregno (out)),
                                       outmode))
         get_secondary_mem (out, outmode, opnum, type);
  #endif
                                       outmode))
         get_secondary_mem (out, outmode, opnum, type);
  #endif
@@ -1472,8 +1527,8 @@ push_reload (in, out, inloc, outloc, class,
             && reg_mentioned_p (XEXP (note, 0), in)
             && ! refers_to_regno_for_reload_p (regno,
                                                (regno
             && reg_mentioned_p (XEXP (note, 0), in)
             && ! refers_to_regno_for_reload_p (regno,
                                                (regno
-                                               + HARD_REGNO_NREGS (regno,
-                                                                   rel_mode)),
+                                               + hard_regno_nregs[regno]
+                                                                 [rel_mode]),
                                                PATTERN (this_insn), inloc)
             /* If this is also an output reload, IN cannot be used as
                the reload register if it is set in this insn unless IN
                                                PATTERN (this_insn), inloc)
             /* If this is also an output reload, IN cannot be used as
                the reload register if it is set in this insn unless IN
@@ -1481,8 +1536,8 @@ push_reload (in, out, inloc, outloc, class,
             && (out == 0 || in == out
                 || ! hard_reg_set_here_p (regno,
                                           (regno
             && (out == 0 || in == out
                 || ! hard_reg_set_here_p (regno,
                                           (regno
-                                          + HARD_REGNO_NREGS (regno,
-                                                              rel_mode)),
+                                          + hard_regno_nregs[regno]
+                                                            [rel_mode]),
                                           PATTERN (this_insn)))
             /* ??? Why is this code so different from the previous?
                Is there any simple coherent way to describe the two together?
                                           PATTERN (this_insn)))
             /* ??? Why is this code so different from the previous?
                Is there any simple coherent way to describe the two together?
@@ -1500,8 +1555,8 @@ push_reload (in, out, inloc, outloc, class,
             && HARD_REGNO_MODE_OK (regno, outmode))
           {
             unsigned int offs;
             && HARD_REGNO_MODE_OK (regno, outmode))
           {
             unsigned int offs;
-           unsigned int nregs = MAX (HARD_REGNO_NREGS (regno, inmode),
-                                     HARD_REGNO_NREGS (regno, outmode));
+           unsigned int nregs = MAX (hard_regno_nregs[regno][inmode],
+                                     hard_regno_nregs[regno][outmode]);
  
             for (offs = 0; offs < nregs; offs++)
               if (fixed_regs[regno + offs]
  
             for (offs = 0; offs < nregs; offs++)
               if (fixed_regs[regno + offs]
@@ -1509,7 +1564,11 @@ push_reload (in, out, inloc, outloc, class,
                                           regno + offs))
                 break;
  
                                           regno + offs))
                 break;
  
-           if (offs == nregs)
+           if (offs == nregs
+               && (! (refers_to_regno_for_reload_p
+                      (regno, (regno + hard_regno_nregs[regno][inmode]),
+                               in, (rtx *)0))
+                   || can_reload_into (in, regno, inmode)))
               {
                 rld[i].reg_rtx = gen_rtx_REG (rel_mode, regno);
                 break;
               {
                 rld[i].reg_rtx = gen_rtx_REG (rel_mode, regno);
                 break;
@@ -1530,10 +1589,7 @@ push_reload (in, out, inloc, outloc, class,
     This is used in insn patterns that use match_dup.  */
  
  static void
     This is used in insn patterns that use match_dup.  */
  
  static void
-push_replacement (loc, reloadnum, mode)
-     rtx *loc;
-     int reloadnum;
-     enum machine_mode mode;
+push_replacement (rtx *loc, int reloadnum, enum machine_mode mode)
  {
    if (replace_reloads)
      {
  {
    if (replace_reloads)
      {
@@ -1544,13 +1600,29 @@ push_replacement (loc, reloadnum, mode)
        r->mode = mode;
      }
  }
        r->mode = mode;
      }
  }
+
+/* Duplicate any replacement we have recorded to apply at
+   location ORIG_LOC to also be performed at DUP_LOC.
+   This is used in insn patterns that use match_dup.  */
+
+static void
+dup_replacements (rtx *dup_loc, rtx *orig_loc)
+{
+  int i, n = n_replacements;
+
+  for (i = 0; i < n; i++)
+    {
+      struct replacement *r = &replacements[i];
+      if (r->where == orig_loc)
+       push_replacement (dup_loc, r->what, r->mode);
+    }
+}
  \f
  /* Transfer all replacements that used to be in reload FROM to be in
     reload TO.  */
  
  void
  \f
  /* Transfer all replacements that used to be in reload FROM to be in
     reload TO.  */
  
  void
-transfer_replacements (to, from)
-     int to, from;
+transfer_replacements (int to, int from)
  {
    int i;
  
  {
    int i;
  
@@ -1562,10 +1634,9 @@ transfer_replacements (to, from)
  /* IN_RTX is the value loaded by a reload that we now decided to inherit,
     or a subpart of it.  If we have any replacements registered for IN_RTX,
     cancel the reloads that were supposed to load them.
  /* IN_RTX is the value loaded by a reload that we now decided to inherit,
     or a subpart of it.  If we have any replacements registered for IN_RTX,
     cancel the reloads that were supposed to load them.
-   Return non-zero if we canceled any reloads.  */
+   Return nonzero if we canceled any reloads.  */
  int
  int
-remove_address_replacements (in_rtx)
-     rtx in_rtx;
+remove_address_replacements (rtx in_rtx)
  {
    int i, j;
    char reload_flags[MAX_RELOADS];
  {
    int i, j;
    char reload_flags[MAX_RELOADS];
@@ -1611,7 +1682,7 @@ remove_address_replacements (in_rtx)
     class and does not appear in the value being output-reloaded.  */
  
  static void
     class and does not appear in the value being output-reloaded.  */
  
  static void
-combine_reloads ()
+combine_reloads (void)
  {
    int i;
    int output_reload = -1;
  {
    int i;
    int output_reload = -1;
@@ -1693,7 +1764,8 @@ combine_reloads ()
                 && ! (GET_CODE (rld[i].in) == REG
                       && reg_overlap_mentioned_for_reload_p (rld[i].in,
                                                              rld[output_reload].out))))
                 && ! (GET_CODE (rld[i].in) == REG
                       && reg_overlap_mentioned_for_reload_p (rld[i].in,
                                                              rld[output_reload].out))))
-       && ! reload_inner_reg_of_subreg (rld[i].in, rld[i].inmode)
+       && ! reload_inner_reg_of_subreg (rld[i].in, rld[i].inmode,
+                                        rld[i].when_needed != RELOAD_FOR_INPUT)
         && (reg_class_size[(int) rld[i].class]
             || SMALL_REGISTER_CLASSES)
         /* We will allow making things slightly worse by combining an
         && (reg_class_size[(int) rld[i].class]
             || SMALL_REGISTER_CLASSES)
         /* We will allow making things slightly worse by combining an
@@ -1765,8 +1837,8 @@ combine_reloads ()
         && HARD_REGNO_MODE_OK (REGNO (XEXP (note, 0)), rld[output_reload].outmode)
         && TEST_HARD_REG_BIT (reg_class_contents[(int) rld[output_reload].class],
                               REGNO (XEXP (note, 0)))
         && HARD_REGNO_MODE_OK (REGNO (XEXP (note, 0)), rld[output_reload].outmode)
         && TEST_HARD_REG_BIT (reg_class_contents[(int) rld[output_reload].class],
                               REGNO (XEXP (note, 0)))
-       && (HARD_REGNO_NREGS (REGNO (XEXP (note, 0)), rld[output_reload].outmode)
-           <= HARD_REGNO_NREGS (REGNO (XEXP (note, 0)), GET_MODE (XEXP (note, 0))))
+       && (hard_regno_nregs[REGNO (XEXP (note, 0))][rld[output_reload].outmode]
+           <= hard_regno_nregs[REGNO (XEXP (note, 0))][GET_MODE (XEXP (note, 0))])
         /* Ensure that a secondary or tertiary reload for this output
            won't want this register.  */
         && ((secondary_out = rld[output_reload].secondary_out_reload) == -1
         /* Ensure that a secondary or tertiary reload for this output
            won't want this register.  */
         && ((secondary_out = rld[output_reload].secondary_out_reload) == -1
@@ -1801,20 +1873,15 @@ combine_reloads ()
     If FOR_REAL is -1, this should not be done, because this call
     is just to see if a register can be found, not to find and install it.
  
     If FOR_REAL is -1, this should not be done, because this call
     is just to see if a register can be found, not to find and install it.
  
-   EARLYCLOBBER is non-zero if OUT is an earlyclobber operand.  This
+   EARLYCLOBBER is nonzero if OUT is an earlyclobber operand.  This
     puts an additional constraint on being able to use IN for OUT since
     IN must not appear elsewhere in the insn (it is assumed that IN itself
     is safe from the earlyclobber).  */
  
  static rtx
     puts an additional constraint on being able to use IN for OUT since
     IN must not appear elsewhere in the insn (it is assumed that IN itself
     is safe from the earlyclobber).  */
  
  static rtx
-find_dummy_reload (real_in, real_out, inloc, outloc,
-                  inmode, outmode, class, for_real, earlyclobber)
-     rtx real_in, real_out;
-     rtx *inloc, *outloc;
-     enum machine_mode inmode, outmode;
-     enum reg_class class;
-     int for_real;
-     int earlyclobber;
+find_dummy_reload (rtx real_in, rtx real_out, rtx *inloc, rtx *outloc,
+                  enum machine_mode inmode, enum machine_mode outmode,
+                  enum reg_class class, int for_real, int earlyclobber)
  {
    rtx in = real_in;
    rtx out = real_out;
  {
    rtx in = real_in;
    rtx out = real_out;
@@ -1863,7 +1930,7 @@ find_dummy_reload (real_in, real_out, inloc, outloc,
        && REGNO (out) < FIRST_PSEUDO_REGISTER)
      {
        unsigned int regno = REGNO (out) + out_offset;
        && REGNO (out) < FIRST_PSEUDO_REGISTER)
      {
        unsigned int regno = REGNO (out) + out_offset;
-      unsigned int nwords = HARD_REGNO_NREGS (regno, outmode);
+      unsigned int nwords = hard_regno_nregs[regno][outmode];
        rtx saved_rtx;
  
        /* When we consider whether the insn uses OUT,
        rtx saved_rtx;
  
        /* When we consider whether the insn uses OUT,
@@ -1879,6 +1946,7 @@ find_dummy_reload (real_in, real_out, inloc, outloc,
        *inloc = const0_rtx;
  
        if (regno < FIRST_PSEUDO_REGISTER
        *inloc = const0_rtx;
  
        if (regno < FIRST_PSEUDO_REGISTER
+         && HARD_REGNO_MODE_OK (regno, outmode)
           && ! refers_to_regno_for_reload_p (regno, regno + nwords,
                                              PATTERN (this_insn), outloc))
         {
           && ! refers_to_regno_for_reload_p (regno, regno + nwords,
                                              PATTERN (this_insn), outloc))
         {
@@ -1923,7 +1991,7 @@ find_dummy_reload (real_in, real_out, inloc, outloc,
                               ? GET_MODE (out) : outmode)))
      {
        unsigned int regno = REGNO (in) + in_offset;
                               ? GET_MODE (out) : outmode)))
      {
        unsigned int regno = REGNO (in) + in_offset;
-      unsigned int nwords = HARD_REGNO_NREGS (regno, inmode);
+      unsigned int nwords = hard_regno_nregs[regno][inmode];
  
        if (! refers_to_regno_for_reload_p (regno, regno + nwords, out, (rtx*) 0)
           && ! hard_reg_set_here_p (regno, regno + nwords,
  
        if (! refers_to_regno_for_reload_p (regno, regno + nwords, out, (rtx*) 0)
           && ! hard_reg_set_here_p (regno, regno + nwords,
@@ -1964,8 +2032,7 @@ find_dummy_reload (real_in, real_out, inloc, outloc,
  /* Return 1 if X is an operand of an insn that is being earlyclobbered.  */
  
  int
  /* Return 1 if X is an operand of an insn that is being earlyclobbered.  */
  
  int
-earlyclobber_operand_p (x)
-     rtx x;
+earlyclobber_operand_p (rtx x)
  {
    int i;
  
  {
    int i;
  
@@ -1982,9 +2049,7 @@ earlyclobber_operand_p (x)
     X should be the body of an instruction.  */
  
  static int
     X should be the body of an instruction.  */
  
  static int
-hard_reg_set_here_p (beg_regno, end_regno, x)
-     unsigned int beg_regno, end_regno;
-     rtx x;
+hard_reg_set_here_p (unsigned int beg_regno, unsigned int end_regno, rtx x)
  {
    if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
      {
  {
    if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
      {
@@ -1998,7 +2063,7 @@ hard_reg_set_here_p (beg_regno, end_regno, x)
  
           /* See if this reg overlaps range under consideration.  */
           if (r < end_regno
  
           /* See if this reg overlaps range under consideration.  */
           if (r < end_regno
-             && r + HARD_REGNO_NREGS (r, GET_MODE (op0)) > beg_regno)
+             && r + hard_regno_nregs[r][GET_MODE (op0)] > beg_regno)
             return 1;
         }
      }
             return 1;
         }
      }
@@ -2019,9 +2084,7 @@ hard_reg_set_here_p (beg_regno, end_regno, x)
     hard reg.  */
  
  int
     hard reg.  */
  
  int
-strict_memory_address_p (mode, addr)
-     enum machine_mode mode ATTRIBUTE_UNUSED;
-     rtx addr;
+strict_memory_address_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx addr)
  {
    GO_IF_LEGITIMATE_ADDRESS (mode, addr, win);
    return 0;
  {
    GO_IF_LEGITIMATE_ADDRESS (mode, addr, win);
    return 0;
@@ -2046,8 +2109,7 @@ strict_memory_address_p (mode, addr)
     because that is natural in (SET output (... input ...)).  */
  
  int
     because that is natural in (SET output (... input ...)).  */
  
  int
-operands_match_p (x, y)
-     rtx x, y;
+operands_match_p (rtx x, rtx y)
  {
    int i;
    RTX_CODE code = GET_CODE (x);
  {
    int i;
    RTX_CODE code = GET_CODE (x);
@@ -2093,23 +2155,23 @@ operands_match_p (x, y)
          (reg:SI 1) will be considered the same register.  */
        if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD
           && i < FIRST_PSEUDO_REGISTER)
          (reg:SI 1) will be considered the same register.  */
        if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD
           && i < FIRST_PSEUDO_REGISTER)
-       i += (GET_MODE_SIZE (GET_MODE (x)) / UNITS_PER_WORD) - 1;
+       i += hard_regno_nregs[i][GET_MODE (x)] - 1;
        if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (y)) > UNITS_PER_WORD
           && j < FIRST_PSEUDO_REGISTER)
        if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (y)) > UNITS_PER_WORD
           && j < FIRST_PSEUDO_REGISTER)
-       j += (GET_MODE_SIZE (GET_MODE (y)) / UNITS_PER_WORD) - 1;
+       j += hard_regno_nregs[j][GET_MODE (y)] - 1;
  
        return i == j;
      }
    /* If two operands must match, because they are really a single
       operand of an assembler insn, then two postincrements are invalid
       because the assembler insn would increment only once.
  
        return i == j;
      }
    /* If two operands must match, because they are really a single
       operand of an assembler insn, then two postincrements are invalid
       because the assembler insn would increment only once.
-     On the other hand, an postincrement matches ordinary indexing
+     On the other hand, a postincrement matches ordinary indexing
       if the postincrement is the output operand.  */
    if (code == POST_DEC || code == POST_INC || code == POST_MODIFY)
      return operands_match_p (XEXP (x, 0), y);
    /* Two preincrements are invalid
       because the assembler insn would increment only once.
       if the postincrement is the output operand.  */
    if (code == POST_DEC || code == POST_INC || code == POST_MODIFY)
      return operands_match_p (XEXP (x, 0), y);
    /* Two preincrements are invalid
       because the assembler insn would increment only once.
-     On the other hand, an preincrement matches ordinary indexing
+     On the other hand, a preincrement matches ordinary indexing
       if the preincrement is the input operand.
       In this case, return 2, since some callers need to do special
       things when this happens.  */
       if the preincrement is the input operand.
       In this case, return 2, since some callers need to do special
       things when this happens.  */
@@ -2198,8 +2260,7 @@ operands_match_p (x, y)
     so we set the SAFE field.  */
  
  static struct decomposition
     so we set the SAFE field.  */
  
  static struct decomposition
-decompose (x)
-     rtx x;
+decompose (rtx x)
  {
    struct decomposition val;
    int all_const = 0;
  {
    struct decomposition val;
    int all_const = 0;
@@ -2309,7 +2370,7 @@ decompose (x)
         }
        else
         /* A hard reg.  */
         }
        else
         /* A hard reg.  */
-       val.end = val.start + HARD_REGNO_NREGS (val.start, GET_MODE (x));
+       val.end = val.start + hard_regno_nregs[val.start][GET_MODE (x)];
      }
    else if (GET_CODE (x) == SUBREG)
      {
      }
    else if (GET_CODE (x) == SUBREG)
      {
@@ -2322,7 +2383,7 @@ decompose (x)
         return decompose (SUBREG_REG (x));
        else
         /* A hard reg.  */
         return decompose (SUBREG_REG (x));
        else
         /* A hard reg.  */
-       val.end = val.start + HARD_REGNO_NREGS (val.start, GET_MODE (x));
+       val.end = val.start + hard_regno_nregs[val.start][GET_MODE (x)];
      }
    else if (CONSTANT_P (x)
            /* This hasn't been assigned yet, so it can't conflict yet.  */
      }
    else if (CONSTANT_P (x)
            /* This hasn't been assigned yet, so it can't conflict yet.  */
@@ -2337,9 +2398,7 @@ decompose (x)
     Y is also described by YDATA, which should be decompose (Y).  */
  
  static int
     Y is also described by YDATA, which should be decompose (Y).  */
  
  static int
-immune_p (x, y, ydata)
-     rtx x, y;
-     struct decomposition ydata;
+immune_p (rtx x, rtx y, struct decomposition ydata)
  {
    struct decomposition xdata;
  
  {
    struct decomposition xdata;
  
@@ -2382,8 +2441,7 @@ immune_p (x, y, ydata)
  /* Similar, but calls decompose.  */
  
  int
  /* Similar, but calls decompose.  */
  
  int
-safe_from_earlyclobber (op, clobber)
-     rtx op, clobber;
+safe_from_earlyclobber (rtx op, rtx clobber)
  {
    struct decomposition early_data;
  
  {
    struct decomposition early_data;
  
@@ -2414,11 +2472,8 @@ safe_from_earlyclobber (op, clobber)
     commutative operands, reg_equiv_address substitution, or whatever.  */
  
  int
     commutative operands, reg_equiv_address substitution, or whatever.  */
  
  int
-find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
-     rtx insn;
-     int replace, ind_levels;
-     int live_known;
-     short *reload_reg_p;
+find_reloads (rtx insn, int replace, int ind_levels, int live_known,
+             short *reload_reg_p)
  {
    int insn_code_number;
    int i, j;
  {
    int insn_code_number;
    int i, j;
@@ -2432,6 +2487,8 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
    char pref_or_nothing[MAX_RECOG_OPERANDS];
    /* Nonzero for a MEM operand whose entire address needs a reload.  */
    int address_reloaded[MAX_RECOG_OPERANDS];
    char pref_or_nothing[MAX_RECOG_OPERANDS];
    /* Nonzero for a MEM operand whose entire address needs a reload.  */
    int address_reloaded[MAX_RECOG_OPERANDS];
+  /* Nonzero for an address operand that needs to be completely reloaded.  */
+  int address_operand_reloaded[MAX_RECOG_OPERANDS];
    /* Value of enum reload_type to use for operand.  */
    enum reload_type operand_type[MAX_RECOG_OPERANDS];
    /* Value of enum reload_type to use within address of operand.  */
    /* Value of enum reload_type to use for operand.  */
    enum reload_type operand_type[MAX_RECOG_OPERANDS];
    /* Value of enum reload_type to use within address of operand.  */
@@ -2493,7 +2550,12 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
    /* The eliminated forms of any secondary memory locations are per-insn, so
       clear them out here.  */
  
    /* The eliminated forms of any secondary memory locations are per-insn, so
       clear them out here.  */
  
-  memset ((char *) secondary_memlocs_elim, 0, sizeof secondary_memlocs_elim);
+  if (secondary_memlocs_elim_used)
+    {
+      memset (secondary_memlocs_elim, 0,
+             sizeof (secondary_memlocs_elim[0]) * secondary_memlocs_elim_used);
+      secondary_memlocs_elim_used = 0;
+    }
  #endif
  
    /* Dispose quickly of (set (reg..) (reg..)) if both have hard regs and it
  #endif
  
    /* Dispose quickly of (set (reg..) (reg..)) if both have hard regs and it
@@ -2545,54 +2607,74 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
        /* Scan this operand's constraint to see if it is an output operand,
          an in-out operand, is commutative, or should match another.  */
  
        /* Scan this operand's constraint to see if it is an output operand,
          an in-out operand, is commutative, or should match another.  */
  
-      while ((c = *p++))
+      while ((c = *p))
         {
         {
-         if (c == '=')
-           modified[i] = RELOAD_WRITE;
-         else if (c == '+')
-           modified[i] = RELOAD_READ_WRITE;
-         else if (c == '%')
+         p += CONSTRAINT_LEN (c, p);
+         switch (c)
             {
             {
-             /* The last operand should not be marked commutative.  */
-             if (i == noperands - 1)
-               abort ();
+           case '=':
+             modified[i] = RELOAD_WRITE;
+             break;
+           case '+':
+             modified[i] = RELOAD_READ_WRITE;
+             break;
+           case '%':
+             {
+               /* The last operand should not be marked commutative.  */
+               if (i == noperands - 1)
+                 abort ();
  
  
-             commutative = i;
-           }
-         else if (ISDIGIT (c))
-           {
-             c = strtoul (p - 1, &p, 10);
+               /* We currently only support one commutative pair of
+                  operands.  Some existing asm code currently uses more
+                  than one pair.  Previously, that would usually work,
+                  but sometimes it would crash the compiler.  We
+                  continue supporting that case as well as we can by
+                  silently ignoring all but the first pair.  In the
+                  future we may handle it correctly.  */
+               if (commutative < 0)
+                 commutative = i;
+               else if (!this_insn_is_asm)
+                 abort ();
+             }
+             break;
+           /* Use of ISDIGIT is tempting here, but it may get expensive because
+              of locale support we don't want.  */
+           case '0': case '1': case '2': case '3': case '4':
+           case '5': case '6': case '7': case '8': case '9':
+             {
+               c = strtoul (p - 1, &p, 10);
  
  
-             operands_match[c][i]
-               = operands_match_p (recog_data.operand[c],
-                                   recog_data.operand[i]);
+               operands_match[c][i]
+                 = operands_match_p (recog_data.operand[c],
+                                     recog_data.operand[i]);
  
  
-             /* An operand may not match itself.  */
-             if (c == i)
-               abort ();
+               /* An operand may not match itself.  */
+               if (c == i)
+                 abort ();
  
  
-             /* If C can be commuted with C+1, and C might need to match I,
-                then C+1 might also need to match I.  */
-             if (commutative >= 0)
-               {
-                 if (c == commutative || c == commutative + 1)
-                   {
-                     int other = c + (c == commutative ? 1 : -1);
-                     operands_match[other][i]
-                       = operands_match_p (recog_data.operand[other],
-                                           recog_data.operand[i]);
-                   }
-                 if (i == commutative || i == commutative + 1)
-                   {
-                     int other = i + (i == commutative ? 1 : -1);
-                     operands_match[c][other]
-                       = operands_match_p (recog_data.operand[c],
-                                           recog_data.operand[other]);
-                   }
-                 /* Note that C is supposed to be less than I.
-                    No need to consider altering both C and I because in
-                    that case we would alter one into the other.  */
-               }
+               /* If C can be commuted with C+1, and C might need to match I,
+                  then C+1 might also need to match I.  */
+               if (commutative >= 0)
+                 {
+                   if (c == commutative || c == commutative + 1)
+                     {
+                       int other = c + (c == commutative ? 1 : -1);
+                       operands_match[other][i]
+                         = operands_match_p (recog_data.operand[other],
+                                             recog_data.operand[i]);
+                     }
+                   if (i == commutative || i == commutative + 1)
+                     {
+                       int other = i + (i == commutative ? 1 : -1);
+                       operands_match[c][other]
+                         = operands_match_p (recog_data.operand[c],
+                                             recog_data.operand[other]);
+                     }
+                   /* Note that C is supposed to be less than I.
+                      No need to consider altering both C and I because in
+                      that case we would alter one into the other.  */
+                 }
+             }
             }
         }
      }
             }
         }
      }
@@ -2610,6 +2692,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
        RTX_CODE code = GET_CODE (recog_data.operand[i]);
  
        address_reloaded[i] = 0;
        RTX_CODE code = GET_CODE (recog_data.operand[i]);
  
        address_reloaded[i] = 0;
+      address_operand_reloaded[i] = 0;
        operand_type[i] = (modified[i] == RELOAD_READ ? RELOAD_FOR_INPUT
                          : modified[i] == RELOAD_WRITE ? RELOAD_FOR_OUTPUT
                          : RELOAD_OTHER);
        operand_type[i] = (modified[i] == RELOAD_READ ? RELOAD_FOR_INPUT
                          : modified[i] == RELOAD_WRITE ? RELOAD_FOR_OUTPUT
                          : RELOAD_OTHER);
@@ -2621,16 +2704,18 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
        if (*constraints[i] == 0)
         /* Ignore things like match_operator operands.  */
         ;
        if (*constraints[i] == 0)
         /* Ignore things like match_operator operands.  */
         ;
-      else if (constraints[i][0] == 'p')
+      else if (constraints[i][0] == 'p'
+              || EXTRA_ADDRESS_CONSTRAINT (constraints[i][0], constraints[i]))
         {
         {
-         find_reloads_address (VOIDmode, (rtx*) 0,
-                               recog_data.operand[i],
-                               recog_data.operand_loc[i],
-                               i, operand_type[i], ind_levels, insn);
+         address_operand_reloaded[i]
+           = find_reloads_address (recog_data.operand_mode[i], (rtx*) 0,
+                                   recog_data.operand[i],
+                                   recog_data.operand_loc[i],
+                                   i, operand_type[i], ind_levels, insn);
  
           /* If we now have a simple operand where we used to have a
              PLUS or MULT, re-recognize and try again.  */
  
           /* If we now have a simple operand where we used to have a
              PLUS or MULT, re-recognize and try again.  */
-         if ((GET_RTX_CLASS (GET_CODE (*recog_data.operand_loc[i])) == 'o'
+         if ((OBJECT_P (*recog_data.operand_loc[i])
                || GET_CODE (*recog_data.operand_loc[i]) == SUBREG)
               && (GET_CODE (recog_data.operand[i]) == MULT
                   || GET_CODE (recog_data.operand[i]) == PLUS))
                || GET_CODE (*recog_data.operand_loc[i]) == SUBREG)
               && (GET_CODE (recog_data.operand[i]) == MULT
                   || GET_CODE (recog_data.operand[i]) == PLUS))
@@ -2643,6 +2728,10 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
  
           recog_data.operand[i] = *recog_data.operand_loc[i];
           substed_operand[i] = recog_data.operand[i];
  
           recog_data.operand[i] = *recog_data.operand_loc[i];
           substed_operand[i] = recog_data.operand[i];
+
+         /* Address operands are reloaded in their existing mode,
+            no matter what is specified in the machine description.  */
+         operand_mode[i] = GET_MODE (recog_data.operand[i]);
         }
        else if (code == MEM)
         {
         }
        else if (code == MEM)
         {
@@ -2682,7 +2771,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
  
           substed_operand[i] = recog_data.operand[i] = op;
         }
  
           substed_operand[i] = recog_data.operand[i] = op;
         }
-      else if (code == PLUS || GET_RTX_CLASS (code) == '1')
+      else if (code == PLUS || GET_RTX_CLASS (code) == RTX_UNARY)
         /* We can get a PLUS as an "operand" as a result of register
            elimination.  See eliminate_regs and gen_reload.  We handle
            a unary operator by reloading the operand.  */
         /* We can get a PLUS as an "operand" as a result of register
            elimination.  See eliminate_regs and gen_reload.  We handle
            a unary operator by reloading the operand.  */
@@ -2786,6 +2875,8 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
        for (i = 0; i < noperands; i++)
         {
           char *p = constraints[i];
        for (i = 0; i < noperands; i++)
         {
           char *p = constraints[i];
+         char *end;
+         int len;
           int win = 0;
           int did_match = 0;
           /* 0 => this operand can be reloaded somehow for this alternative.  */
           int win = 0;
           int did_match = 0;
           /* 0 => this operand can be reloaded somehow for this alternative.  */
@@ -2793,6 +2884,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
           /* 0 => this operand can be reloaded if the alternative allows regs.  */
           int winreg = 0;
           int c;
           /* 0 => this operand can be reloaded if the alternative allows regs.  */
           int winreg = 0;
           int c;
+         int m;
           rtx operand = recog_data.operand[i];
           int offset = 0;
           /* Nonzero means this is a MEM that must be reloaded into a reg
           rtx operand = recog_data.operand[i];
           int offset = 0;
           /* Nonzero means this is a MEM that must be reloaded into a reg
@@ -2807,7 +2899,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
           /* If the predicate accepts a unary operator, it means that
              we need to reload the operand, but do not do this for
              match_operator and friends.  */
           /* If the predicate accepts a unary operator, it means that
              we need to reload the operand, but do not do this for
              match_operator and friends.  */
-         if (GET_RTX_CLASS (GET_CODE (operand)) == '1' && *p != 0)
+         if (UNARY_P (operand) && *p != 0)
             operand = XEXP (operand, 0);
  
           /* If the operand is a SUBREG, extract
             operand = XEXP (operand, 0);
  
           /* If the operand is a SUBREG, extract
@@ -2823,6 +2915,12 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
               if (GET_CODE (SUBREG_REG (operand)) == REG
                   && REGNO (SUBREG_REG (operand)) < FIRST_PSEUDO_REGISTER)
                 {
               if (GET_CODE (SUBREG_REG (operand)) == REG
                   && REGNO (SUBREG_REG (operand)) < FIRST_PSEUDO_REGISTER)
                 {
+                 if (!subreg_offset_representable_p
+                       (REGNO (SUBREG_REG (operand)),
+                        GET_MODE (SUBREG_REG (operand)),
+                        SUBREG_BYTE (operand),
+                        GET_MODE (operand)))
+                    force_reload = 1;
                   offset += subreg_regno_offset (REGNO (SUBREG_REG (operand)),
                                                  GET_MODE (SUBREG_REG (operand)),
                                                  SUBREG_BYTE (operand),
                   offset += subreg_regno_offset (REGNO (SUBREG_REG (operand)),
                                                  GET_MODE (SUBREG_REG (operand)),
                                                  SUBREG_BYTE (operand),
@@ -2851,11 +2949,11 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
  
                      This is doubly true if WORD_REGISTER_OPERATIONS.  In
                      this case eliminate_regs has left non-paradoxical
  
                      This is doubly true if WORD_REGISTER_OPERATIONS.  In
                      this case eliminate_regs has left non-paradoxical
-                    subregs for push_reloads to see.  Make sure it does
+                    subregs for push_reload to see.  Make sure it does
                      by forcing the reload.
  
                      ??? When is it right at this stage to have a subreg
                      by forcing the reload.
  
                      ??? When is it right at this stage to have a subreg
-                    of a mem that is _not_ to be handled specialy?  IMO
+                    of a mem that is _not_ to be handled specially?  IMO
                      those should have been reduced to just a mem.  */
                   || ((GET_CODE (operand) == MEM
                        || (GET_CODE (operand)== REG
                      those should have been reduced to just a mem.  */
                   || ((GET_CODE (operand) == MEM
                        || (GET_CODE (operand)== REG
@@ -2878,26 +2976,6 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
                           )
  #endif
                       )
                           )
  #endif
                       )
-                 /* This following hunk of code should no longer be
-                    needed at all with SUBREG_BYTE.  If you need this
-                    code back, please explain to me why so I can
-                    fix the real problem.  -DaveM */
-#if 0
-                 /* Subreg of a hard reg which can't handle the subreg's mode
-                    or which would handle that mode in the wrong number of
-                    registers for subregging to work.  */
-                 || (GET_CODE (operand) == REG
-                     && REGNO (operand) < FIRST_PSEUDO_REGISTER
-                     && ((GET_MODE_SIZE (operand_mode[i]) <= UNITS_PER_WORD
-                          && (GET_MODE_SIZE (GET_MODE (operand))
-                              > UNITS_PER_WORD)
-                          && ((GET_MODE_SIZE (GET_MODE (operand))
-                               / UNITS_PER_WORD)
-                              != HARD_REGNO_NREGS (REGNO (operand),
-                                                   GET_MODE (operand))))
-                         || ! HARD_REGNO_MODE_OK (REGNO (operand) + offset,
-                                                  operand_mode[i])))
-#endif
                   )
                 force_reload = 1;
             }
                   )
                 force_reload = 1;
             }
@@ -2921,16 +2999,22 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
              or set WINREG if this operand could fit after reloads
              provided the constraint allows some registers.  */
  
              or set WINREG if this operand could fit after reloads
              provided the constraint allows some registers.  */
  
-         while (*p && (c = *p++) != ',')
-           switch (c)
+         do
+           switch ((c = *p, len = CONSTRAINT_LEN (c, p)), c)
               {
               {
+             case '\0':
+               len = 0;
+               break;
+             case ',':
+               c = '\0';
+               break;
+
               case '=':  case '+':  case '*':
                 break;
  
               case '%':
               case '=':  case '+':  case '*':
                 break;
  
               case '%':
-               /* The last operand should not be marked commutative.  */
-               if (i != noperands - 1)
-                 commutative = i;
+               /* We only support one commutative marker, the first
+                  one.  We already set commutative above.  */
                 break;
  
               case '?':
                 break;
  
               case '?':
@@ -2944,15 +3028,19 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
               case '#':
                 /* Ignore rest of this alternative as far as
                    reloading is concerned.  */
               case '#':
                 /* Ignore rest of this alternative as far as
                    reloading is concerned.  */
-               while (*p && *p != ',')
+               do
                   p++;
                   p++;
+               while (*p && *p != ',');
+               len = 0;
                 break;
  
               case '0':  case '1':  case '2':  case '3':  case '4':
               case '5':  case '6':  case '7':  case '8':  case '9':
                 break;
  
               case '0':  case '1':  case '2':  case '3':  case '4':
               case '5':  case '6':  case '7':  case '8':  case '9':
-               c = strtoul (p - 1, &p, 10);
+               m = strtoul (p, &end, 10);
+               p = end;
+               len = 0;
  
  
-               this_alternative_matches[i] = c;
+               this_alternative_matches[i] = m;
                 /* We are supposed to match a previous operand.
                    If we do, we win if that one did.
                    If we do not, count both of the operands as losers.
                 /* We are supposed to match a previous operand.
                    If we do, we win if that one did.
                    If we do not, count both of the operands as losers.
@@ -2960,7 +3048,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
                    only a single reload insn will be needed to make
                    the two operands win.  As a result, this alternative
                    may be rejected when it is actually desirable.)  */
                    only a single reload insn will be needed to make
                    the two operands win.  As a result, this alternative
                    may be rejected when it is actually desirable.)  */
-               if ((swapped && (c != commutative || i != commutative + 1))
+               if ((swapped && (m != commutative || i != commutative + 1))
                     /* If we are matching as if two operands were swapped,
                        also pretend that operands_match had been computed
                        with swapped.
                     /* If we are matching as if two operands were swapped,
                        also pretend that operands_match had been computed
                        with swapped.
@@ -2968,22 +3056,22 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
                        don't exchange them, because operands_match is valid
                        only on one side of its diagonal.  */
                     ? (operands_match
                        don't exchange them, because operands_match is valid
                        only on one side of its diagonal.  */
                     ? (operands_match
-                      [(c == commutative || c == commutative + 1)
-                      ? 2 * commutative + 1 - c : c]
+                      [(m == commutative || m == commutative + 1)
+                      ? 2 * commutative + 1 - m : m]
                        [(i == commutative || i == commutative + 1)
                        ? 2 * commutative + 1 - i : i])
                        [(i == commutative || i == commutative + 1)
                        ? 2 * commutative + 1 - i : i])
-                   : operands_match[c][i])
+                   : operands_match[m][i])
                   {
                     /* If we are matching a non-offsettable address where an
                        offsettable address was expected, then we must reject
                        this combination, because we can't reload it.  */
                   {
                     /* If we are matching a non-offsettable address where an
                        offsettable address was expected, then we must reject
                        this combination, because we can't reload it.  */
-                   if (this_alternative_offmemok[c]
-                       && GET_CODE (recog_data.operand[c]) == MEM
-                       && this_alternative[c] == (int) NO_REGS
-                       && ! this_alternative_win[c])
+                   if (this_alternative_offmemok[m]
+                       && GET_CODE (recog_data.operand[m]) == MEM
+                       && this_alternative[m] == (int) NO_REGS
+                       && ! this_alternative_win[m])
                       bad = 1;
  
                       bad = 1;
  
-                   did_match = this_alternative_win[c];
+                   did_match = this_alternative_win[m];
                   }
                 else
                   {
                   }
                 else
                   {
@@ -2991,21 +3079,21 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
                     rtx value;
                     /* Retroactively mark the operand we had to match
                        as a loser, if it wasn't already.  */
                     rtx value;
                     /* Retroactively mark the operand we had to match
                        as a loser, if it wasn't already.  */
-                   if (this_alternative_win[c])
+                   if (this_alternative_win[m])
                       losers++;
                       losers++;
-                   this_alternative_win[c] = 0;
-                   if (this_alternative[c] == (int) NO_REGS)
+                   this_alternative_win[m] = 0;
+                   if (this_alternative[m] == (int) NO_REGS)
                       bad = 1;
                     /* But count the pair only once in the total badness of
                        this alternative, if the pair can be a dummy reload.  */
                     value
                       = find_dummy_reload (recog_data.operand[i],
                       bad = 1;
                     /* But count the pair only once in the total badness of
                        this alternative, if the pair can be a dummy reload.  */
                     value
                       = find_dummy_reload (recog_data.operand[i],
-                                          recog_data.operand[c],
+                                          recog_data.operand[m],
                                            recog_data.operand_loc[i],
                                            recog_data.operand_loc[i],
-                                          recog_data.operand_loc[c],
-                                          operand_mode[i], operand_mode[c],
-                                          this_alternative[c], -1,
-                                          this_alternative_earlyclobber[c]);
+                                          recog_data.operand_loc[m],
+                                          operand_mode[i], operand_mode[m],
+                                          this_alternative[m], -1,
+                                          this_alternative_earlyclobber[m]);
  
                     if (value != 0)
                       losers--;
  
                     if (value != 0)
                       losers--;
@@ -3013,7 +3101,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
                 /* This can be fixed with reloads if the operand
                    we are supposed to match can be fixed with reloads.  */
                 badop = 0;
                 /* This can be fixed with reloads if the operand
                    we are supposed to match can be fixed with reloads.  */
                 badop = 0;
-               this_alternative[i] = this_alternative[c];
+               this_alternative[i] = this_alternative[m];
  
                 /* If we have to reload this operand and some previous
                    operand also had to match the same thing as this
  
                 /* If we have to reload this operand and some previous
                    operand also had to match the same thing as this
@@ -3031,6 +3119,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
                    were handled in find_reloads_address.  */
                 this_alternative[i] = (int) MODE_BASE_REG_CLASS (VOIDmode);
                 win = 1;
                    were handled in find_reloads_address.  */
                 this_alternative[i] = (int) MODE_BASE_REG_CLASS (VOIDmode);
                 win = 1;
+               badop = 0;
                 break;
  
               case 'm':
                 break;
  
               case 'm':
@@ -3041,9 +3130,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
                         && REGNO (operand) >= FIRST_PSEUDO_REGISTER
                         && reg_renumber[REGNO (operand)] < 0))
                   win = 1;
                         && REGNO (operand) >= FIRST_PSEUDO_REGISTER
                         && reg_renumber[REGNO (operand)] < 0))
                   win = 1;
-               if (CONSTANT_P (operand)
-                   /* force_const_mem does not accept HIGH.  */
-                   && GET_CODE (operand) != HIGH)
+               if (CONST_POOL_OK_P (operand))
                   badop = 0;
                 constmemok = 1;
                 break;
                   badop = 0;
                 constmemok = 1;
                 break;
@@ -3105,8 +3192,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
                              && offsettable_memref_p (reg_equiv_mem[REGNO (operand)]))
                             || (reg_equiv_address[REGNO (operand)] != 0))))
                   win = 1;
                              && offsettable_memref_p (reg_equiv_mem[REGNO (operand)]))
                             || (reg_equiv_address[REGNO (operand)] != 0))))
                   win = 1;
-               /* force_const_mem does not accept HIGH.  */
-               if ((CONSTANT_P (operand) && GET_CODE (operand) != HIGH)
+               if (CONST_POOL_OK_P (operand)
                     || GET_CODE (operand) == MEM)
                   badop = 0;
                 constmemok = 1;
                     || GET_CODE (operand) == MEM)
                   badop = 0;
                 constmemok = 1;
@@ -3120,27 +3206,18 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
                 break;
  
               case 'E':
                 break;
  
               case 'E':
-#ifndef REAL_ARITHMETIC
-               /* Match any floating double constant, but only if
-                  we can examine the bits of it reliably.  */
-               if ((HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
-                    || HOST_BITS_PER_WIDE_INT != BITS_PER_WORD)
-                   && GET_MODE (operand) != VOIDmode && ! flag_pretend_float)
-                 break;
-#endif
-               if (GET_CODE (operand) == CONST_DOUBLE)
-                 win = 1;
-               break;
-
               case 'F':
               case 'F':
-               if (GET_CODE (operand) == CONST_DOUBLE)
+               if (GET_CODE (operand) == CONST_DOUBLE
+                   || (GET_CODE (operand) == CONST_VECTOR
+                       && (GET_MODE_CLASS (GET_MODE (operand))
+                           == MODE_VECTOR_FLOAT)))
                   win = 1;
                 break;
  
               case 'G':
               case 'H':
                 if (GET_CODE (operand) == CONST_DOUBLE
                   win = 1;
                 break;
  
               case 'G':
               case 'H':
                 if (GET_CODE (operand) == CONST_DOUBLE
-                   && CONST_DOUBLE_OK_FOR_LETTER_P (operand, c))
+                   && CONST_DOUBLE_OK_FOR_CONSTRAINT_P (operand, c, p))
                   win = 1;
                 break;
  
                   win = 1;
                 break;
  
@@ -3174,7 +3251,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
               case 'O':
               case 'P':
                 if (GET_CODE (operand) == CONST_INT
               case 'O':
               case 'P':
                 if (GET_CODE (operand) == CONST_INT
-                   && CONST_OK_FOR_LETTER_P (INTVAL (operand), c))
+                   && CONST_OK_FOR_CONSTRAINT_P (INTVAL (operand), c, p))
                   win = 1;
                 break;
  
                   win = 1;
                 break;
  
@@ -3207,17 +3284,63 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
                 goto reg;
  
               default:
                 goto reg;
  
               default:
-               if (REG_CLASS_FROM_LETTER (c) == NO_REGS)
+               if (REG_CLASS_FROM_CONSTRAINT (c, p) == NO_REGS)
                   {
                   {
-#ifdef EXTRA_CONSTRAINT
-                   if (EXTRA_CONSTRAINT (operand, c))
+#ifdef EXTRA_CONSTRAINT_STR
+                   if (EXTRA_MEMORY_CONSTRAINT (c, p))
+                     {
+                       if (force_reload)
+                         break;
+                       if (EXTRA_CONSTRAINT_STR (operand, c, p))
+                         win = 1;
+                       /* If the address was already reloaded,
+                          we win as well.  */
+                       else if (GET_CODE (operand) == MEM
+                                && address_reloaded[i])
+                         win = 1;
+                       /* Likewise if the address will be reloaded because
+                          reg_equiv_address is nonzero.  For reg_equiv_mem
+                          we have to check.  */
+                       else if (GET_CODE (operand) == REG
+                                && REGNO (operand) >= FIRST_PSEUDO_REGISTER
+                                && reg_renumber[REGNO (operand)] < 0
+                                && ((reg_equiv_mem[REGNO (operand)] != 0
+                                     && EXTRA_CONSTRAINT_STR (reg_equiv_mem[REGNO (operand)], c, p))
+                                    || (reg_equiv_address[REGNO (operand)] != 0)))
+                         win = 1;
+
+                       /* If we didn't already win, we can reload
+                          constants via force_const_mem, and other
+                          MEMs by reloading the address like for 'o'.  */
+                       if (CONST_POOL_OK_P (operand)
+                           || GET_CODE (operand) == MEM)
+                         badop = 0;
+                       constmemok = 1;
+                       offmemok = 1;
+                       break;
+                     }
+                   if (EXTRA_ADDRESS_CONSTRAINT (c, p))
+                     {
+                       if (EXTRA_CONSTRAINT_STR (operand, c, p))
+                         win = 1;
+
+                       /* If we didn't already win, we can reload
+                          the address into a base register.  */
+                       this_alternative[i] = (int) MODE_BASE_REG_CLASS (VOIDmode);
+                       badop = 0;
+                       break;
+                     }
+
+                   if (EXTRA_CONSTRAINT_STR (operand, c, p))
                       win = 1;
  #endif
                     break;
                   }
  
                 this_alternative[i]
                       win = 1;
  #endif
                     break;
                   }
  
                 this_alternative[i]
-                 = (int) reg_class_subunion[this_alternative[i]][(int) REG_CLASS_FROM_LETTER (c)];
+                 = (int) (reg_class_subunion
+                          [this_alternative[i]]
+                          [(int) REG_CLASS_FROM_CONSTRAINT (c, p)]);
               reg:
                 if (GET_MODE (operand) == BLKmode)
                   break;
               reg:
                 if (GET_MODE (operand) == BLKmode)
                   break;
@@ -3228,6 +3351,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
                   win = 1;
                 break;
               }
                   win = 1;
                 break;
               }
+         while ((p += len), c);
  
           constraints[i] = p;
  
  
           constraints[i] = p;
  
@@ -3264,9 +3388,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
                  an early reload pass.  Note that the test here is
                  precisely the same as in the code below that calls
                  force_const_mem.  */
                  an early reload pass.  Note that the test here is
                  precisely the same as in the code below that calls
                  force_const_mem.  */
-             if (CONSTANT_P (operand)
-                 /* force_const_mem does not accept HIGH.  */
-                 && GET_CODE (operand) != HIGH
+             if (CONST_POOL_OK_P (operand)
                   && ((PREFERRED_RELOAD_CLASS (operand,
                                                (enum reg_class) this_alternative[i])
                        == NO_REGS)
                   && ((PREFERRED_RELOAD_CLASS (operand,
                                                (enum reg_class) this_alternative[i])
                        == NO_REGS)
@@ -3572,7 +3694,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
  
    for (i = 0; i < noperands; i++)
      goal_alternative_matched[i] = -1;
  
    for (i = 0; i < noperands; i++)
      goal_alternative_matched[i] = -1;
- 
+
    for (i = 0; i < noperands; i++)
      if (! goal_alternative_win[i]
         && goal_alternative_matches[i] >= 0)
    for (i = 0; i < noperands; i++)
      if (! goal_alternative_win[i]
         && goal_alternative_matches[i] >= 0)
@@ -3640,9 +3762,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
       into registers are here changed into memory references.  */
    for (i = 0; i < noperands; i++)
      if (! goal_alternative_win[i]
       into registers are here changed into memory references.  */
    for (i = 0; i < noperands; i++)
      if (! goal_alternative_win[i]
-       && CONSTANT_P (recog_data.operand[i])
-       /* force_const_mem does not accept HIGH.  */
-       && GET_CODE (recog_data.operand[i]) != HIGH
+       && CONST_POOL_OK_P (recog_data.operand[i])
         && ((PREFERRED_RELOAD_CLASS (recog_data.operand[i],
                                      (enum reg_class) goal_alternative[i])
              == NO_REGS)
         && ((PREFERRED_RELOAD_CLASS (recog_data.operand[i],
                                      (enum reg_class) goal_alternative[i])
              == NO_REGS)
@@ -3776,6 +3896,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
        }
      else if (goal_alternative_matched[i] < 0
              && goal_alternative_matches[i] < 0
        }
      else if (goal_alternative_matched[i] < 0
              && goal_alternative_matches[i] < 0
+            && !address_operand_reloaded[i]
              && optimize)
        {
         /* For each non-matching operand that's a MEM or a pseudo-register
              && optimize)
        {
         /* For each non-matching operand that's a MEM or a pseudo-register
@@ -3923,9 +4044,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
        {
         int opno = recog_data.dup_num[i];
         *recog_data.dup_loc[i] = *recog_data.operand_loc[opno];
        {
         int opno = recog_data.dup_num[i];
         *recog_data.dup_loc[i] = *recog_data.operand_loc[opno];
-       if (operand_reloadnum[opno] >= 0)
-         push_replacement (recog_data.dup_loc[i], operand_reloadnum[opno],
-                           insn_data[insn_code_number].operand[opno].mode);
+       dup_replacements (recog_data.dup_loc[i], recog_data.operand_loc[opno]);
        }
  
  #if 0
        }
  
  #if 0
@@ -4246,16 +4365,26 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
    for (i = 0; i < n_reloads; i++)
      if (rld[i].when_needed == RELOAD_FOR_INPUT
         && GET_CODE (PATTERN (insn)) == SET
    for (i = 0; i < n_reloads; i++)
      if (rld[i].when_needed == RELOAD_FOR_INPUT
         && GET_CODE (PATTERN (insn)) == SET
-       && GET_CODE (SET_DEST (PATTERN (insn))) == REG
-       && SET_SRC (PATTERN (insn)) == rld[i].in)
+       && GET_CODE (SET_DEST (PATTERN (insn))) == REG
+       && SET_SRC (PATTERN (insn)) == rld[i].in)
        {
        {
-       rtx dest = SET_DEST (PATTERN (insn));
+       rtx dest = SET_DEST (PATTERN (insn));
         unsigned int regno = REGNO (dest);
  
         unsigned int regno = REGNO (dest);
  
-       if (regno < FIRST_PSEUDO_REGISTER
-           && TEST_HARD_REG_BIT (reg_class_contents[rld[i].class], regno)
-           && HARD_REGNO_MODE_OK (regno, rld[i].mode))
-         rld[i].reg_rtx = dest;
+       if (regno < FIRST_PSEUDO_REGISTER
+           && TEST_HARD_REG_BIT (reg_class_contents[rld[i].class], regno)
+           && HARD_REGNO_MODE_OK (regno, rld[i].mode))
+         {
+           int nr = hard_regno_nregs[regno][rld[i].mode];
+           int ok = 1, nri;
+
+           for (nri = 1; nri < nr; nri ++)
+             if (! TEST_HARD_REG_BIT (reg_class_contents[rld[i].class], regno + nri))
+               ok = 0;
+
+           if (ok)
+             rld[i].reg_rtx = dest;
+         }
        }
  
    return retval;
        }
  
    return retval;
@@ -4265,9 +4394,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
     accepts a memory operand with constant address.  */
  
  static int
     accepts a memory operand with constant address.  */
  
  static int
-alternative_allows_memconst (constraint, altnum)
-     const char *constraint;
-     int altnum;
+alternative_allows_memconst (const char *constraint, int altnum)
  {
    int c;
    /* Skip alternatives before the one requested.  */
  {
    int c;
    /* Skip alternatives before the one requested.  */
@@ -4278,8 +4405,9 @@ alternative_allows_memconst (constraint, altnum)
      }
    /* Scan the requested alternative for 'm' or 'o'.
       If one of them is present, this alternative accepts memory constants.  */
      }
    /* Scan the requested alternative for 'm' or 'o'.
       If one of them is present, this alternative accepts memory constants.  */
-  while ((c = *constraint++) && c != ',' && c != '#')
-    if (c == 'm' || c == 'o')
+  for (; (c = *constraint) && c != ',' && c != '#';
+       constraint += CONSTRAINT_LEN (c, constraint))
+    if (c == 'm' || c == 'o' || EXTRA_MEMORY_CONSTRAINT (c, constraint))
        return 1;
    return 0;
  }
        return 1;
    return 0;
  }
@@ -4307,15 +4435,9 @@ alternative_allows_memconst (constraint, altnum)
     result of find_reloads_address.  */
  
  static rtx
     result of find_reloads_address.  */
  
  static rtx
-find_reloads_toplev (x, opnum, type, ind_levels, is_set_dest, insn,
-                    address_reloaded)
-     rtx x;
-     int opnum;
-     enum reload_type type;
-     int ind_levels;
-     int is_set_dest;
-     rtx insn;
-     int *address_reloaded;
+find_reloads_toplev (rtx x, int opnum, enum reload_type type,
+                    int ind_levels, int is_set_dest, rtx insn,
+                    int *address_reloaded)
  {
    RTX_CODE code = GET_CODE (x);
  
  {
    RTX_CODE code = GET_CODE (x);
  
@@ -4393,53 +4515,17 @@ find_reloads_toplev (x, opnum, type, ind_levels, is_set_dest, insn,
                                         reg_equiv_constant[regno])) != 0)
         return tem;
  
                                         reg_equiv_constant[regno])) != 0)
         return tem;
  
-      if (GET_MODE_BITSIZE (GET_MODE (x)) == BITS_PER_WORD
-         && regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
-         && reg_equiv_constant[regno] != 0
-         && (tem = operand_subword (reg_equiv_constant[regno],
-                                    SUBREG_BYTE (x) / UNITS_PER_WORD, 0,
-                                    GET_MODE (SUBREG_REG (x)))) != 0)
+      if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
+         && reg_equiv_constant[regno] != 0)
         {
         {
-         /* TEM is now a word sized constant for the bits from X that
-            we wanted.  However, TEM may be the wrong representation.
-
-            Use gen_lowpart_common to convert a CONST_INT into a
-            CONST_DOUBLE and vice versa as needed according to by the mode
-            of the SUBREG.  */
-         tem = gen_lowpart_common (GET_MODE (x), tem);
+         tem =
+           simplify_gen_subreg (GET_MODE (x), reg_equiv_constant[regno],
+                                GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
           if (!tem)
             abort ();
           return tem;
         }
  
           if (!tem)
             abort ();
           return tem;
         }
  
-      /* If the SUBREG is wider than a word, the above test will fail.
-        For example, we might have a SImode SUBREG of a DImode SUBREG_REG
-        for a 16 bit target, or a DImode SUBREG of a TImode SUBREG_REG for
-        a 32 bit target.  We still can - and have to - handle this
-        for non-paradoxical subregs of CONST_INTs.  */
-      if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
-         && reg_equiv_constant[regno] != 0
-         && GET_CODE (reg_equiv_constant[regno]) == CONST_INT
-         && (GET_MODE_SIZE (GET_MODE (x))
-             < GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))))
-       {
-         int shift = SUBREG_BYTE (x) * BITS_PER_UNIT;
-         if (WORDS_BIG_ENDIAN)
-           shift = (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x)))
-                    - GET_MODE_BITSIZE (GET_MODE (x))
-                    - shift);
-         /* Here we use the knowledge that CONST_INTs have a
-            HOST_WIDE_INT field.  */
-         if (shift >= HOST_BITS_PER_WIDE_INT)
-           shift = HOST_BITS_PER_WIDE_INT - 1;
-         return GEN_INT (INTVAL (reg_equiv_constant[regno]) >> shift);
-       }
-
-      if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
-         && reg_equiv_constant[regno] != 0
-         && GET_MODE (reg_equiv_constant[regno]) == VOIDmode)
-       abort ();
-
        /* If the subreg contains a reg that will be converted to a mem,
          convert the subreg to a narrower memref now.
          Otherwise, we would get (subreg (mem ...) ...),
        /* If the subreg contains a reg that will be converted to a mem,
          convert the subreg to a narrower memref now.
          Otherwise, we would get (subreg (mem ...) ...),
@@ -4495,9 +4581,7 @@ find_reloads_toplev (x, opnum, type, ind_levels, is_set_dest, insn,
     This mem ref is not shared with anything.  */
  
  static rtx
     This mem ref is not shared with anything.  */
  
  static rtx
-make_memloc (ad, regno)
-     rtx ad;
-     int regno;
+make_memloc (rtx ad, int regno)
  {
    /* We must rerun eliminate_regs, in case the elimination
       offsets have changed.  */
  {
    /* We must rerun eliminate_regs, in case the elimination
       offsets have changed.  */
@@ -4519,6 +4603,24 @@ make_memloc (ad, regno)
    return tem;
  }
  
    return tem;
  }
  
+/* Returns true if AD could be turned into a valid memory reference
+   to mode MODE by reloading the part pointed to by PART into a
+   register.  */
+
+static int
+maybe_memory_address_p (enum machine_mode mode, rtx ad, rtx *part)
+{
+  int retv;
+  rtx tem = *part;
+  rtx reg = gen_rtx_REG (GET_MODE (tem), max_reg_num ());
+
+  *part = reg;
+  retv = memory_address_p (mode, ad);
+  *part = tem;
+
+  return retv;
+}
+
  /* Record all reloads needed for handling memory address AD
     which appears in *LOC in a memory reference to mode MODE
     which itself is found in location  *MEMREFLOC.
  /* Record all reloads needed for handling memory address AD
     which appears in *LOC in a memory reference to mode MODE
     which itself is found in location  *MEMREFLOC.
@@ -4544,15 +4646,9 @@ make_memloc (ad, regno)
     to a hard register, and frame pointer elimination.  */
  
  static int
     to a hard register, and frame pointer elimination.  */
  
  static int
-find_reloads_address (mode, memrefloc, ad, loc, opnum, type, ind_levels, insn)
-     enum machine_mode mode;
-     rtx *memrefloc;
-     rtx ad;
-     rtx *loc;
-     int opnum;
-     enum reload_type type;
-     int ind_levels;
-     rtx insn;
+find_reloads_address (enum machine_mode mode, rtx *memrefloc, rtx ad,
+                     rtx *loc, int opnum, enum reload_type type,
+                     int ind_levels, rtx insn)
  {
    int regno;
    int removed_and = 0;
  {
    int regno;
    int removed_and = 0;
@@ -4585,9 +4681,9 @@ find_reloads_address (mode, memrefloc, ad, loc, opnum, type, ind_levels, insn)
               tem = make_memloc (ad, regno);
               if (! strict_memory_address_p (GET_MODE (tem), XEXP (tem, 0)))
                 {
               tem = make_memloc (ad, regno);
               if (! strict_memory_address_p (GET_MODE (tem), XEXP (tem, 0)))
                 {
-                 find_reloads_address (GET_MODE (tem), (rtx*) 0, XEXP (tem, 0),
-                                       &XEXP (tem, 0), opnum, ADDR_TYPE (type),
-                                       ind_levels, insn);
+                 find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
+                                       &XEXP (tem, 0), opnum,
+                                       ADDR_TYPE (type), ind_levels, insn);
                 }
               /* We can avoid a reload if the register's equivalent memory
                  expression is valid as an indirect memory address.
                 }
               /* We can avoid a reload if the register's equivalent memory
                  expression is valid as an indirect memory address.
@@ -4799,18 +4895,24 @@ find_reloads_address (mode, memrefloc, ad, loc, opnum, type, ind_levels, insn)
       that the index needs a reload and find_reloads_address_1 will take care
       of it.
  
       that the index needs a reload and find_reloads_address_1 will take care
       of it.
  
-     If we decide to do something here, it must be that
-     `double_reg_address_ok' is true and that this address rtl was made by
-     eliminate_regs.  We generate a reload of the fp/sp/ap + constant and
+     Handle all base registers here, not just fp/ap/sp, because on some
+     targets (namely SPARC) we can also get invalid addresses from preventive
+     subreg big-endian corrections made by find_reloads_toplev.
+
+     If we decide to do something, it must be that `double_reg_address_ok'
+     is true.  We generate a reload of the base register + constant and
       rework the sum so that the reload register will be added to the index.
       This is safe because we know the address isn't shared.
  
       rework the sum so that the reload register will be added to the index.
       This is safe because we know the address isn't shared.
  
-     We check for fp/ap/sp as both the first and second operand of the
-     innermost PLUS.  */
+     We check for the base register as both the first and second operand of
+     the innermost PLUS.  */
  
    else if (GET_CODE (ad) == PLUS && GET_CODE (XEXP (ad, 1)) == CONST_INT
            && GET_CODE (XEXP (ad, 0)) == PLUS
  
    else if (GET_CODE (ad) == PLUS && GET_CODE (XEXP (ad, 1)) == CONST_INT
            && GET_CODE (XEXP (ad, 0)) == PLUS
-          && (XEXP (XEXP (ad, 0), 0) == frame_pointer_rtx
+          && GET_CODE (XEXP (XEXP (ad, 0), 0)) == REG
+          && REGNO (XEXP (XEXP (ad, 0), 0)) < FIRST_PSEUDO_REGISTER
+          && (REG_MODE_OK_FOR_BASE_P (XEXP (XEXP (ad, 0), 0), mode)
+              || XEXP (XEXP (ad, 0), 0) == frame_pointer_rtx
  #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
                || XEXP (XEXP (ad, 0), 0) == hard_frame_pointer_rtx
  #endif
  #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
                || XEXP (XEXP (ad, 0), 0) == hard_frame_pointer_rtx
  #endif
@@ -4818,7 +4920,7 @@ find_reloads_address (mode, memrefloc, ad, loc, opnum, type, ind_levels, insn)
                || XEXP (XEXP (ad, 0), 0) == arg_pointer_rtx
  #endif
                || XEXP (XEXP (ad, 0), 0) == stack_pointer_rtx)
                || XEXP (XEXP (ad, 0), 0) == arg_pointer_rtx
  #endif
                || XEXP (XEXP (ad, 0), 0) == stack_pointer_rtx)
-          && ! memory_address_p (mode, ad))
+          && ! maybe_memory_address_p (mode, ad, &XEXP (XEXP (ad, 0), 1)))
      {
        *loc = ad = gen_rtx_PLUS (GET_MODE (ad),
                                 plus_constant (XEXP (XEXP (ad, 0), 0),
      {
        *loc = ad = gen_rtx_PLUS (GET_MODE (ad),
                                 plus_constant (XEXP (XEXP (ad, 0), 0),
@@ -4835,15 +4937,18 @@ find_reloads_address (mode, memrefloc, ad, loc, opnum, type, ind_levels, insn)
  
    else if (GET_CODE (ad) == PLUS && GET_CODE (XEXP (ad, 1)) == CONST_INT
            && GET_CODE (XEXP (ad, 0)) == PLUS
  
    else if (GET_CODE (ad) == PLUS && GET_CODE (XEXP (ad, 1)) == CONST_INT
            && GET_CODE (XEXP (ad, 0)) == PLUS
-          && (XEXP (XEXP (ad, 0), 1) == frame_pointer_rtx
-#if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
+          && GET_CODE (XEXP (XEXP (ad, 0), 1)) == REG
+          && REGNO (XEXP (XEXP (ad, 0), 1)) < FIRST_PSEUDO_REGISTER
+          && (REG_MODE_OK_FOR_BASE_P (XEXP (XEXP (ad, 0), 1), mode)
+              || XEXP (XEXP (ad, 0), 1) == frame_pointer_rtx
+#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
                || XEXP (XEXP (ad, 0), 1) == hard_frame_pointer_rtx
  #endif
  #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
                || XEXP (XEXP (ad, 0), 1) == arg_pointer_rtx
  #endif
                || XEXP (XEXP (ad, 0), 1) == stack_pointer_rtx)
                || XEXP (XEXP (ad, 0), 1) == hard_frame_pointer_rtx
  #endif
  #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
                || XEXP (XEXP (ad, 0), 1) == arg_pointer_rtx
  #endif
                || XEXP (XEXP (ad, 0), 1) == stack_pointer_rtx)
-          && ! memory_address_p (mode, ad))
+          && ! maybe_memory_address_p (mode, ad, &XEXP (XEXP (ad, 0), 0)))
      {
        *loc = ad = gen_rtx_PLUS (GET_MODE (ad),
                                 XEXP (XEXP (ad, 0), 0),
      {
        *loc = ad = gen_rtx_PLUS (GET_MODE (ad),
                                 XEXP (XEXP (ad, 0), 0),
@@ -4912,9 +5017,7 @@ find_reloads_address (mode, memrefloc, ad, loc, opnum, type, ind_levels, insn)
     front of it for pseudos that we have to replace with stack slots.  */
  
  static rtx
     front of it for pseudos that we have to replace with stack slots.  */
  
  static rtx
-subst_reg_equivs (ad, insn)
-     rtx ad;
-     rtx insn;
+subst_reg_equivs (rtx ad, rtx insn)
  {
    RTX_CODE code = GET_CODE (ad);
    int i;
  {
    RTX_CODE code = GET_CODE (ad);
    int i;
@@ -4926,6 +5029,7 @@ subst_reg_equivs (ad, insn)
      case CONST_INT:
      case CONST:
      case CONST_DOUBLE:
      case CONST_INT:
      case CONST:
      case CONST_DOUBLE:
+    case CONST_VECTOR:
      case SYMBOL_REF:
      case LABEL_REF:
      case PC:
      case SYMBOL_REF:
      case LABEL_REF:
      case PC:
@@ -4984,8 +5088,7 @@ subst_reg_equivs (ad, insn)
     This routine assumes both inputs are already in canonical form.  */
  
  rtx
     This routine assumes both inputs are already in canonical form.  */
  
  rtx
-form_sum (x, y)
-     rtx x, y;
+form_sum (rtx x, rtx y)
  {
    rtx tem;
    enum machine_mode mode = GET_MODE (x);
  {
    rtx tem;
    enum machine_mode mode = GET_MODE (x);
@@ -5039,8 +5142,7 @@ form_sum (x, y)
     In all other cases, return ADDR.  */
  
  static rtx
     In all other cases, return ADDR.  */
  
  static rtx
-subst_indexed_address (addr)
-     rtx addr;
+subst_indexed_address (rtx addr)
  {
    rtx op0 = 0, op1 = 0, op2 = 0;
    rtx tem;
  {
    rtx op0 = 0, op1 = 0, op2 = 0;
    rtx tem;
@@ -5097,17 +5199,15 @@ subst_indexed_address (addr)
     RELOADNUM is the reload number.  */
  
  static void
     RELOADNUM is the reload number.  */
  
  static void
-update_auto_inc_notes (insn, regno, reloadnum)
-     rtx insn ATTRIBUTE_UNUSED;
-     int regno ATTRIBUTE_UNUSED;
-     int reloadnum ATTRIBUTE_UNUSED;
+update_auto_inc_notes (rtx insn ATTRIBUTE_UNUSED, int regno ATTRIBUTE_UNUSED,
+                      int reloadnum ATTRIBUTE_UNUSED)
  {
  #ifdef AUTO_INC_DEC
    rtx link;
  
    for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
      if (REG_NOTE_KIND (link) == REG_INC
  {
  #ifdef AUTO_INC_DEC
    rtx link;
  
    for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
      if (REG_NOTE_KIND (link) == REG_INC
-        && REGNO (XEXP (link, 0)) == regno)
+        && (int) REGNO (XEXP (link, 0)) == regno)
        push_replacement (&XEXP (link, 0), reloadnum, VOIDmode);
  #endif
  }
        push_replacement (&XEXP (link, 0), reloadnum, VOIDmode);
  #endif
  }
@@ -5137,15 +5237,9 @@ update_auto_inc_notes (insn, regno, reloadnum)
     could have addressing modes that this does not handle right.  */
  
  static int
     could have addressing modes that this does not handle right.  */
  
  static int
-find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
-     enum machine_mode mode;
-     rtx x;
-     int context;
-     rtx *loc;
-     int opnum;
-     enum reload_type type;
-     int ind_levels;
-     rtx insn;
+find_reloads_address_1 (enum machine_mode mode, rtx x, int context,
+                       rtx *loc, int opnum, enum reload_type type,
+                       int ind_levels, rtx insn)
  {
    RTX_CODE code = GET_CODE (x);
  
  {
    RTX_CODE code = GET_CODE (x);
  
@@ -5187,6 +5281,19 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
                                                        SUBREG_BYTE (orig_op1),
                                                        GET_MODE (orig_op1))));
           }
                                                        SUBREG_BYTE (orig_op1),
                                                        GET_MODE (orig_op1))));
           }
+       /* Plus in the index register may be created only as a result of
+          register remateralization for expression like &localvar*4.  Reload it.
+          It may be possible to combine the displacement on the outer level,
+          but it is probably not worthwhile to do so.  */
+       if (context)
+         {
+           find_reloads_address (GET_MODE (x), loc, XEXP (x, 0), &XEXP (x, 0),
+                                 opnum, ADDR_TYPE (type), ind_levels, insn);
+           push_reload (*loc, NULL_RTX, loc, (rtx*) 0,
+                        (context ? INDEX_REG_CLASS : MODE_BASE_REG_CLASS (mode)),
+                        GET_MODE (x), VOIDmode, 0, 0, opnum, type);
+           return 1;
+         }
  
         if (code0 == MULT || code0 == SIGN_EXTEND || code0 == TRUNCATE
             || code0 == ZERO_EXTEND || code1 == MEM)
  
         if (code0 == MULT || code0 == SIGN_EXTEND || code0 == TRUNCATE
             || code0 == ZERO_EXTEND || code1 == MEM)
@@ -5301,7 +5408,7 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
  
             /* Handle a register that is equivalent to a memory location
                which cannot be addressed directly.  */
  
             /* Handle a register that is equivalent to a memory location
                which cannot be addressed directly.  */
-           if (reg_equiv_memory_loc[regno] != 0
+           if (reg_equiv_memory_loc[regno] != 0
                 && (reg_equiv_address[regno] != 0
                     || num_not_at_initial_offset))
               {
                 && (reg_equiv_address[regno] != 0
                     || num_not_at_initial_offset))
               {
@@ -5314,7 +5421,7 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
                        We can't use ADDR_TYPE (type) here, because we need to
                        write back the value after reading it, hence we actually
                        need two registers.  */
                        We can't use ADDR_TYPE (type) here, because we need to
                        write back the value after reading it, hence we actually
                        need two registers.  */
-                   find_reloads_address (GET_MODE (tem), 0, XEXP (tem, 0),
+                   find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
                                           &XEXP (tem, 0), opnum,
                                           RELOAD_OTHER,
                                           ind_levels, insn);
                                           &XEXP (tem, 0), opnum,
                                           RELOAD_OTHER,
                                           ind_levels, insn);
@@ -5599,7 +5706,7 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
              needless copies if SUBREG_REG is multi-word.  */
           if (REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
             {
              needless copies if SUBREG_REG is multi-word.  */
           if (REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
             {
-             int regno = subreg_regno (x);
+             int regno ATTRIBUTE_UNUSED = subreg_regno (x);
  
               if (! (context ? REGNO_OK_FOR_INDEX_P (regno)
                      : REGNO_MODE_OK_FOR_BASE_P (regno, mode)))
  
               if (! (context ? REGNO_OK_FOR_INDEX_P (regno)
                      : REGNO_MODE_OK_FOR_BASE_P (regno, mode)))
@@ -5617,7 +5724,7 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
             {
               enum reg_class class = (context ? INDEX_REG_CLASS
                                       : MODE_BASE_REG_CLASS (mode));
             {
               enum reg_class class = (context ? INDEX_REG_CLASS
                                       : MODE_BASE_REG_CLASS (mode));
-             if (CLASS_MAX_NREGS (class, GET_MODE (SUBREG_REG (x)))
+             if ((unsigned) CLASS_MAX_NREGS (class, GET_MODE (SUBREG_REG (x)))
                   > reg_class_size[class])
                 {
                   x = find_reloads_subreg_address (x, 0, opnum, type,
                   > reg_class_size[class])
                 {
                   x = find_reloads_subreg_address (x, 0, opnum, type,
@@ -5665,14 +5772,9 @@ find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
     supports.  */
  
  static void
     supports.  */
  
  static void
-find_reloads_address_part (x, loc, class, mode, opnum, type, ind_levels)
-     rtx x;
-     rtx *loc;
-     enum reg_class class;
-     enum machine_mode mode;
-     int opnum;
-     enum reload_type type;
-     int ind_levels;
+find_reloads_address_part (rtx x, rtx *loc, enum reg_class class,
+                          enum machine_mode mode, int opnum,
+                          enum reload_type type, int ind_levels)
  {
    if (CONSTANT_P (x)
        && (! LEGITIMATE_CONSTANT_P (x)
  {
    if (CONSTANT_P (x)
        && (! LEGITIMATE_CONSTANT_P (x)
@@ -5725,14 +5827,8 @@ find_reloads_address_part (x, loc, class, mode, opnum, type, ind_levels)
     stack slots.  */
  
  static rtx
     stack slots.  */
  
  static rtx
-find_reloads_subreg_address (x, force_replace, opnum, type,
-                            ind_levels, insn)
-     rtx x;
-     int force_replace;
-     int opnum;
-     enum reload_type type;
-     int ind_levels;
-     rtx insn;
+find_reloads_subreg_address (rtx x, int force_replace, int opnum,
+                            enum reload_type type, int ind_levels, rtx insn)
  {
    int regno = REGNO (SUBREG_REG (x));
  
  {
    int regno = REGNO (SUBREG_REG (x));
  
@@ -5754,9 +5850,16 @@ find_reloads_subreg_address (x, force_replace, opnum, type,
           if (force_replace
               || ! rtx_equal_p (tem, reg_equiv_mem[regno]))
             {
           if (force_replace
               || ! rtx_equal_p (tem, reg_equiv_mem[regno]))
             {
-             int offset = SUBREG_BYTE (x);
               unsigned outer_size = GET_MODE_SIZE (GET_MODE (x));
               unsigned inner_size = GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)));
               unsigned outer_size = GET_MODE_SIZE (GET_MODE (x));
               unsigned inner_size = GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)));
+             int offset;
+
+             /* For big-endian paradoxical subregs, SUBREG_BYTE does not
+                hold the correct (negative) byte offset.  */
+             if (BYTES_BIG_ENDIAN && outer_size > inner_size)
+               offset = inner_size - outer_size;
+             else
+               offset = SUBREG_BYTE (x);
  
               XEXP (tem, 0) = plus_constant (XEXP (tem, 0), offset);
               PUT_MODE (tem, GET_MODE (x));
  
               XEXP (tem, 0) = plus_constant (XEXP (tem, 0), offset);
               PUT_MODE (tem, GET_MODE (x));
@@ -5811,8 +5914,7 @@ find_reloads_subreg_address (x, force_replace, opnum, type,
     Return the rtx that X translates into; usually X, but modified.  */
  
  void
     Return the rtx that X translates into; usually X, but modified.  */
  
  void
-subst_reloads (insn)
-     rtx insn;
+subst_reloads (rtx insn)
  {
    int i;
  
  {
    int i;
  
@@ -5862,7 +5964,7 @@ subst_reloads (insn)
              do the wrong thing if RELOADREG is multi-word.  RELOADREG
              will always be a REG here.  */
           if (GET_MODE (reloadreg) != r->mode && r->mode != VOIDmode)
              do the wrong thing if RELOADREG is multi-word.  RELOADREG
              will always be a REG here.  */
           if (GET_MODE (reloadreg) != r->mode && r->mode != VOIDmode)
-           reloadreg = gen_rtx_REG (r->mode, REGNO (reloadreg));
+           reloadreg = reload_adjust_reg_for_mode (reloadreg, r->mode);
  
           /* If we are putting this into a SUBREG and RELOADREG is a
              SUBREG, we would be making nested SUBREGs, so we have to fix
  
           /* If we are putting this into a SUBREG and RELOADREG is a
              SUBREG, we would be making nested SUBREGs, so we have to fix
@@ -5898,54 +6000,69 @@ subst_reloads (insn)
      }
  }
  \f
      }
  }
  \f
-/* Make a copy of any replacements being done into X and move those copies
-   to locations in Y, a copy of X.  We only look at the highest level of
-   the RTL.  */
+/* Make a copy of any replacements being done into X and move those
+   copies to locations in Y, a copy of X.  */
  
  void
  
  void
-copy_replacements (x, y)
-     rtx x;
-     rtx y;
+copy_replacements (rtx x, rtx y)
  {
  {
-  int i, j;
-  enum rtx_code code = GET_CODE (x);
-  const char *fmt = GET_RTX_FORMAT (code);
-  struct replacement *r;
-
    /* We can't support X being a SUBREG because we might then need to know its
       location if something inside it was replaced.  */
    /* We can't support X being a SUBREG because we might then need to know its
       location if something inside it was replaced.  */
-  if (code == SUBREG)
+  if (GET_CODE (x) == SUBREG)
      abort ();
  
      abort ();
  
-  for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
-    if (fmt[i] == 'e')
-      for (j = 0; j < n_replacements; j++)
+  copy_replacements_1 (&x, &y, n_replacements);
+}
+
+static void
+copy_replacements_1 (rtx *px, rtx *py, int orig_replacements)
+{
+  int i, j;
+  rtx x, y;
+  struct replacement *r;
+  enum rtx_code code;
+  const char *fmt;
+
+  for (j = 0; j < orig_replacements; j++)
+    {
+      if (replacements[j].subreg_loc == px)
         {
         {
-         if (replacements[j].subreg_loc == &XEXP (x, i))
-           {
-             r = &replacements[n_replacements++];
-             r->where = replacements[j].where;
-             r->subreg_loc = &XEXP (y, i);
-             r->what = replacements[j].what;
-             r->mode = replacements[j].mode;
-           }
-         else if (replacements[j].where == &XEXP (x, i))
-           {
-             r = &replacements[n_replacements++];
-             r->where = &XEXP (y, i);
-             r->subreg_loc = 0;
-             r->what = replacements[j].what;
-             r->mode = replacements[j].mode;
-           }
+         r = &replacements[n_replacements++];
+         r->where = replacements[j].where;
+         r->subreg_loc = py;
+         r->what = replacements[j].what;
+         r->mode = replacements[j].mode;
+       }
+      else if (replacements[j].where == px)
+       {
+         r = &replacements[n_replacements++];
+         r->where = py;
+         r->subreg_loc = 0;
+         r->what = replacements[j].what;
+         r->mode = replacements[j].mode;
         }
         }
+    }
+
+  x = *px;
+  y = *py;
+  code = GET_CODE (x);
+  fmt = GET_RTX_FORMAT (code);
+
+  for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
+    {
+      if (fmt[i] == 'e')
+       copy_replacements_1 (&XEXP (x, i), &XEXP (y, i), orig_replacements);
+      else if (fmt[i] == 'E')
+       for (j = XVECLEN (x, i); --j >= 0; )
+         copy_replacements_1 (&XVECEXP (x, i, j), &XVECEXP (y, i, j),
+                              orig_replacements);
+    }
  }
  
  }
  
-/* Change any replacements being done to *X to be done to *Y */
+/* Change any replacements being done to *X to be done to *Y.  */
  
  void
  
  void
-move_replacements (x, y)
-     rtx *x;
-     rtx *y;
+move_replacements (rtx *x, rtx *y)
  {
    int i;
  
  {
    int i;
  
@@ -5963,8 +6080,7 @@ move_replacements (x, y)
     Otherwise, return *LOC.  */
  
  rtx
     Otherwise, return *LOC.  */
  
  rtx
-find_replacement (loc)
-     rtx *loc;
+find_replacement (rtx *loc)
  {
    struct replacement *r;
  
  {
    struct replacement *r;
  
@@ -6034,10 +6150,8 @@ find_replacement (loc)
     look at equivalences for pseudos that didn't get hard registers.  */
  
  int
     look at equivalences for pseudos that didn't get hard registers.  */
  
  int
-refers_to_regno_for_reload_p (regno, endregno, x, loc)
-     unsigned int regno, endregno;
-     rtx x;
-     rtx *loc;
+refers_to_regno_for_reload_p (unsigned int regno, unsigned int endregno,
+                             rtx x, rtx *loc)
  {
    int i;
    unsigned int r;
  {
    int i;
    unsigned int r;
@@ -6072,7 +6186,7 @@ refers_to_regno_for_reload_p (regno, endregno, x, loc)
  
        return (endregno > r
               && regno < r + (r < FIRST_PSEUDO_REGISTER
  
        return (endregno > r
               && regno < r + (r < FIRST_PSEUDO_REGISTER
-                             ? HARD_REGNO_NREGS (r, GET_MODE (x))
+                             ? hard_regno_nregs[r][GET_MODE (x)]
                               : 1));
  
      case SUBREG:
                               : 1));
  
      case SUBREG:
@@ -6084,7 +6198,7 @@ refers_to_regno_for_reload_p (regno, endregno, x, loc)
           unsigned int inner_regno = subreg_regno (x);
           unsigned int inner_endregno
             = inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
           unsigned int inner_regno = subreg_regno (x);
           unsigned int inner_endregno
             = inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
-                            ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
+                            ? hard_regno_nregs[inner_regno][GET_MODE (x)] : 1);
  
           return endregno > inner_regno && regno < inner_endregno;
         }
  
           return endregno > inner_regno && regno < inner_endregno;
         }
@@ -6160,14 +6274,13 @@ refers_to_regno_for_reload_p (regno, endregno, x, loc)
     that we look at equivalences for pseudos that didn't get hard registers.  */
  
  int
     that we look at equivalences for pseudos that didn't get hard registers.  */
  
  int
-reg_overlap_mentioned_for_reload_p (x, in)
-     rtx x, in;
+reg_overlap_mentioned_for_reload_p (rtx x, rtx in)
  {
    int regno, endregno;
  
    /* Overly conservative.  */
    if (GET_CODE (x) == STRICT_LOW_PART
  {
    int regno, endregno;
  
    /* Overly conservative.  */
    if (GET_CODE (x) == STRICT_LOW_PART
-      || GET_RTX_CLASS (GET_CODE (x)) == 'a')
+      || GET_RTX_CLASS (GET_CODE (x)) == RTX_AUTOINC)
      x = XEXP (x, 0);
  
    /* If either argument is a constant, then modifying X can not affect IN.  */
      x = XEXP (x, 0);
  
    /* If either argument is a constant, then modifying X can not affect IN.  */
@@ -6204,13 +6317,27 @@ reg_overlap_mentioned_for_reload_p (x, in)
            || GET_CODE (x) == CC0)
      return reg_mentioned_p (x, in);
    else if (GET_CODE (x) == PLUS)
            || GET_CODE (x) == CC0)
      return reg_mentioned_p (x, in);
    else if (GET_CODE (x) == PLUS)
-    return (reg_overlap_mentioned_for_reload_p (XEXP (x, 0), in)
-           || reg_overlap_mentioned_for_reload_p (XEXP (x, 1), in));
+    {
+      /* We actually want to know if X is mentioned somewhere inside IN.
+        We must not say that (plus (sp) (const_int 124)) is in
+        (plus (sp) (const_int 64)), since that can lead to incorrect reload
+        allocation when spuriously changing a RELOAD_FOR_OUTPUT_ADDRESS
+        into a RELOAD_OTHER on behalf of another RELOAD_OTHER.  */
+      while (GET_CODE (in) == MEM)
+       in = XEXP (in, 0);
+      if (GET_CODE (in) == REG)
+       return 0;
+      else if (GET_CODE (in) == PLUS)
+       return (reg_overlap_mentioned_for_reload_p (x, XEXP (in, 0))
+               || reg_overlap_mentioned_for_reload_p (x, XEXP (in, 1)));
+      else return (reg_overlap_mentioned_for_reload_p (XEXP (x, 0), in)
+                  || reg_overlap_mentioned_for_reload_p (XEXP (x, 1), in));
+    }
    else
      abort ();
  
    endregno = regno + (regno < FIRST_PSEUDO_REGISTER
    else
      abort ();
  
    endregno = regno + (regno < FIRST_PSEUDO_REGISTER
-                     ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
+                     ? hard_regno_nregs[regno][GET_MODE (x)] : 1);
  
    return refers_to_regno_for_reload_p (regno, endregno, in, (rtx*) 0);
  }
  
    return refers_to_regno_for_reload_p (regno, endregno, in, (rtx*) 0);
  }
@@ -6219,8 +6346,7 @@ reg_overlap_mentioned_for_reload_p (x, in)
     registers.  */
  
  int
     registers.  */
  
  int
-refers_to_mem_for_reload_p (x)
-     rtx x;
+refers_to_mem_for_reload_p (rtx x)
  {
    const char *fmt;
    int i;
  {
    const char *fmt;
    int i;
@@ -6270,14 +6396,8 @@ refers_to_mem_for_reload_p (x)
     as if it were a constant except that sp is required to be unchanging.  */
  
  rtx
     as if it were a constant except that sp is required to be unchanging.  */
  
  rtx
-find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
-     rtx goal;
-     rtx insn;
-     enum reg_class class;
-     int other;
-     short *reload_reg_p;
-     int goalreg;
-     enum machine_mode mode;
+find_equiv_reg (rtx goal, rtx insn, enum reg_class class, int other,
+               short *reload_reg_p, int goalreg, enum machine_mode mode)
  {
    rtx p = insn;
    rtx goaltry, valtry, value, where;
  {
    rtx p = insn;
    rtx goaltry, valtry, value, where;
@@ -6290,6 +6410,7 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
    int need_stable_sp = 0;
    int nregs;
    int valuenregs;
    int need_stable_sp = 0;
    int nregs;
    int valuenregs;
+  int num = 0;
  
    if (goal == 0)
      regno = goalreg;
  
    if (goal == 0)
      regno = goalreg;
@@ -6330,6 +6451,7 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
    else
      return 0;
  
    else
      return 0;
  
+  num = 0;
    /* Scan insns back from INSN, looking for one that copies
       a value into or out of GOAL.
       Stop and give up if we reach a label.  */
    /* Scan insns back from INSN, looking for one that copies
       a value into or out of GOAL.
       Stop and give up if we reach a label.  */
@@ -6337,7 +6459,9 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
    while (1)
      {
        p = PREV_INSN (p);
    while (1)
      {
        p = PREV_INSN (p);
-      if (p == 0 || GET_CODE (p) == CODE_LABEL)
+      num++;
+      if (p == 0 || GET_CODE (p) == CODE_LABEL
+         || num > PARAM_VALUE (PARAM_MAX_RELOAD_SEARCH_INSNS))
         return 0;
  
        if (GET_CODE (p) == INSN
         return 0;
  
        if (GET_CODE (p) == INSN
@@ -6424,7 +6548,7 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
                 {
                   int i;
  
                 {
                   int i;
  
-                 for (i = HARD_REGNO_NREGS (valueno, mode) - 1; i >= 0; i--)
+                 for (i = hard_regno_nregs[valueno][mode] - 1; i >= 0; i--)
                     if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
                                              valueno + i))
                       break;
                     if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
                                              valueno + i))
                       break;
@@ -6466,20 +6590,22 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
    if (goal_mem && value == SET_DEST (single_set (where))
        && refers_to_regno_for_reload_p (valueno,
                                        (valueno
    if (goal_mem && value == SET_DEST (single_set (where))
        && refers_to_regno_for_reload_p (valueno,
                                        (valueno
-                                       + HARD_REGNO_NREGS (valueno, mode)),
+                                       + hard_regno_nregs[valueno][mode]),
                                        goal, (rtx*) 0))
      return 0;
  
    /* Reject registers that overlap GOAL.  */
  
                                        goal, (rtx*) 0))
      return 0;
  
    /* Reject registers that overlap GOAL.  */
  
+  if (regno >= 0 && regno < FIRST_PSEUDO_REGISTER)
+    nregs = hard_regno_nregs[regno][mode];
+  else
+    nregs = 1;
+  valuenregs = hard_regno_nregs[valueno][mode];
+
    if (!goal_mem && !goal_const
    if (!goal_mem && !goal_const
-      && regno + (int) HARD_REGNO_NREGS (regno, mode) > valueno
-      && regno < valueno + (int) HARD_REGNO_NREGS (valueno, mode))
+      && regno + nregs > valueno && regno < valueno + valuenregs)
      return 0;
  
      return 0;
  
-  nregs = HARD_REGNO_NREGS (regno, mode);
-  valuenregs = HARD_REGNO_NREGS (valueno, mode);
-
    /* Reject VALUE if it is one of the regs reserved for reloads.
       Reload1 knows how to reuse them anyway, and it would get
       confused if we allocated one without its knowledge.
    /* Reject VALUE if it is one of the regs reserved for reloads.
       Reload1 knows how to reuse them anyway, and it would get
       confused if we allocated one without its knowledge.
@@ -6504,8 +6630,8 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
         if (rld[i].reg_rtx != 0 && rld[i].in)
           {
             int regno1 = REGNO (rld[i].reg_rtx);
         if (rld[i].reg_rtx != 0 && rld[i].in)
           {
             int regno1 = REGNO (rld[i].reg_rtx);
-           int nregs1 = HARD_REGNO_NREGS (regno1,
-                                          GET_MODE (rld[i].reg_rtx));
+           int nregs1 = hard_regno_nregs[regno1]
+                                        [GET_MODE (rld[i].reg_rtx)];
             if (regno1 < valueno + valuenregs
                 && regno1 + nregs1 > valueno)
               return 0;
             if (regno1 < valueno + valuenregs
                 && regno1 + nregs1 > valueno)
               return 0;
@@ -6579,7 +6705,7 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
                   int xregno = REGNO (dest);
                   int xnregs;
                   if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
                   int xregno = REGNO (dest);
                   int xnregs;
                   if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
-                   xnregs = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
+                   xnregs = hard_regno_nregs[xregno][GET_MODE (dest)];
                   else
                     xnregs = 1;
                   if (xregno < regno + nregs && xregno + xnregs > regno)
                   else
                     xnregs = 1;
                   if (xregno < regno + nregs && xregno + xnregs > regno)
@@ -6623,7 +6749,7 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
                           int xregno = REGNO (dest);
                           int xnregs;
                           if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
                           int xregno = REGNO (dest);
                           int xnregs;
                           if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
-                           xnregs = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
+                           xnregs = hard_regno_nregs[xregno][GET_MODE (dest)];
                           else
                             xnregs = 1;
                           if (xregno < regno + nregs
                           else
                             xnregs = 1;
                           if (xregno < regno + nregs
@@ -6668,7 +6794,7 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
                         {
                           int xregno = REGNO (dest);
                           int xnregs
                         {
                           int xregno = REGNO (dest);
                           int xnregs
-                           = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
+                           = hard_regno_nregs[xregno][GET_MODE (dest)];
  
                           if (xregno < regno + nregs
                               && xregno + xnregs > regno)
  
                           if (xregno < regno + nregs
                               && xregno + xnregs > regno)
@@ -6725,8 +6851,7 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
     The value is always positive.  */
  
  static int
     The value is always positive.  */
  
  static int
-find_inc_amount (x, inced)
-     rtx x, inced;
+find_inc_amount (rtx x, rtx inced)
  {
    enum rtx_code code = GET_CODE (x);
    const char *fmt;
  {
    enum rtx_code code = GET_CODE (x);
    const char *fmt;
@@ -6781,13 +6906,10 @@ find_inc_amount (x, inced)
     If SETS is nonzero, also consider SETs.  */
  
  int
     If SETS is nonzero, also consider SETs.  */
  
  int
-regno_clobbered_p (regno, insn, mode, sets)
-     unsigned int regno;
-     rtx insn;
-     enum machine_mode mode;
-     int sets;
+regno_clobbered_p (unsigned int regno, rtx insn, enum machine_mode mode,
+                  int sets)
  {
  {
-  unsigned int nregs = HARD_REGNO_NREGS (regno, mode);
+  unsigned int nregs = hard_regno_nregs[regno][mode];
    unsigned int endregno = regno + nregs;
  
    if ((GET_CODE (PATTERN (insn)) == CLOBBER
    unsigned int endregno = regno + nregs;
  
    if ((GET_CODE (PATTERN (insn)) == CLOBBER
@@ -6811,7 +6933,7 @@ regno_clobbered_p (regno, insn, mode, sets)
               && GET_CODE (XEXP (elt, 0)) == REG)
             {
               unsigned int test = REGNO (XEXP (elt, 0));
               && GET_CODE (XEXP (elt, 0)) == REG)
             {
               unsigned int test = REGNO (XEXP (elt, 0));
-             
+
               if (test >= regno && test < endregno)
                 return 1;
             }
               if (test >= regno && test < endregno)
                 return 1;
             }
@@ -6821,6 +6943,24 @@ regno_clobbered_p (regno, insn, mode, sets)
    return 0;
  }
  
    return 0;
  }
  
+/* Find the low part, with mode MODE, of a hard regno RELOADREG.  */
+rtx
+reload_adjust_reg_for_mode (rtx reloadreg, enum machine_mode mode)
+{
+  int regno;
+
+  if (GET_MODE (reloadreg) == mode)
+    return reloadreg;
+
+  regno = REGNO (reloadreg);
+
+  if (WORDS_BIG_ENDIAN)
+    regno += (int) hard_regno_nregs[regno][GET_MODE (reloadreg)]
+      - (int) hard_regno_nregs[regno][mode];
+
+  return gen_rtx_REG (mode, regno);
+}
+
  static const char *const reload_when_needed_name[] =
  {
    "RELOAD_FOR_INPUT",
  static const char *const reload_when_needed_name[] =
  {
    "RELOAD_FOR_INPUT",
@@ -6841,8 +6981,7 @@ static const char * const reg_class_names[] = REG_CLASS_NAMES;
  /* These functions are used to print the variables set by 'find_reloads' */
  
  void
  /* These functions are used to print the variables set by 'find_reloads' */
  
  void
-debug_reload_to_stream (f)
-     FILE *f;
+debug_reload_to_stream (FILE *f)
  {
    int r;
    const char *prefix;
  {
    int r;
    const char *prefix;
@@ -6937,7 +7076,7 @@ debug_reload_to_stream (f)
  }
  
  void
  }
  
  void
-debug_reload ()
+debug_reload (void)
  {
    debug_reload_to_stream (stderr);
  }
  {
    debug_reload_to_stream (stderr);
  }