gcc/reload.c

   1 /* Search an insn for pseudo regs that must be in hard regs and are not.
   2    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 /* This file contains subroutines used only from the file reload1.c.
  23    It knows how to scan one insn for operands and values
  24    that need to be copied into registers to make valid code.
  25    It also finds other operands and values which are valid
  26    but for which equivalent values in registers exist and
  27    ought to be used instead.
  28
  29    Before processing the first insn of the function, call `init_reload'.
  30
  31    To scan an insn, call `find_reloads'.  This does two things:
  32    1. sets up tables describing which values must be reloaded
  33    for this insn, and what kind of hard regs they must be reloaded into;
  34    2. optionally record the locations where those values appear in
  35    the data, so they can be replaced properly later.
  36    This is done only if the second arg to `find_reloads' is nonzero.
  37
  38    The third arg to `find_reloads' specifies the number of levels
  39    of indirect addressing supported by the machine.  If it is zero,
  40    indirect addressing is not valid.  If it is one, (MEM (REG n))
  41    is valid even if (REG n) did not get a hard register; if it is two,
  42    (MEM (MEM (REG n))) is also valid even if (REG n) did not get a
  43    hard register, and similarly for higher values.
  44
  45    Then you must choose the hard regs to reload those pseudo regs into,
  46    and generate appropriate load insns before this insn and perhaps
  47    also store insns after this insn.  Set up the array `reload_reg_rtx'
  48    to contain the REG rtx's for the registers you used.  In some
  49    cases `find_reloads' will return a nonzero value in `reload_reg_rtx'
  50    for certain reloads.  Then that tells you which register to use,
  51    so you do not need to allocate one.  But you still do need to add extra
  52    instructions to copy the value into and out of that register.
  53
  54    Finally you must call `subst_reloads' to substitute the reload reg rtx's
  55    into the locations already recorded.
  56
  57 NOTE SIDE EFFECTS:
  58
  59    find_reloads can alter the operands of the instruction it is called on.
  60
  61    1. Two operands of any sort may be interchanged, if they are in a
  62    commutative instruction.
  63    This happens only if find_reloads thinks the instruction will compile
  64    better that way.
  65
  66    2. Pseudo-registers that are equivalent to constants are replaced
  67    with those constants if they are not in hard registers.
  68
  69 1 happens every time find_reloads is called.
  70 2 happens only when REPLACE is 1, which is only when
  71 actually doing the reloads, not when just counting them.
  72
  73 Using a reload register for several reloads in one insn:
  74
  75 When an insn has reloads, it is considered as having three parts:
  76 the input reloads, the insn itself after reloading, and the output reloads.
  77 Reloads of values used in memory addresses are often needed for only one part.
  78
  79 When this is so, reload_when_needed records which part needs the reload.
  80 Two reloads for different parts of the insn can share the same reload
  81 register.
  82
  83 When a reload is used for addresses in multiple parts, or when it is
  84 an ordinary operand, it is classified as RELOAD_OTHER, and cannot share
  85 a register with any other reload.  */
  86
  87 #define REG_OK_STRICT
  88
  89 #include "config.h"
  90 #include "system.h"
  91 #include "coretypes.h"
  92 #include "tm.h"
  93 #include "rtl.h"
  94 #include "tm_p.h"
  95 #include "insn-config.h"
  96 #include "expr.h"
  97 #include "optabs.h"
  98 #include "recog.h"
  99 #include "reload.h"
 100 #include "regs.h"
 101 #include "hard-reg-set.h"
 102 #include "flags.h"
 103 #include "real.h"
 104 #include "output.h"
 105 #include "function.h"
 106 #include "toplev.h"
 107
 108 #ifndef REGISTER_MOVE_COST
 109 #define REGISTER_MOVE_COST(m, x, y) 2
 110 #endif
 111
 112 #ifndef REGNO_MODE_OK_FOR_BASE_P
 113 #define REGNO_MODE_OK_FOR_BASE_P(REGNO, MODE) REGNO_OK_FOR_BASE_P (REGNO)
 114 #endif
 115
 116 #ifndef REG_MODE_OK_FOR_BASE_P
 117 #define REG_MODE_OK_FOR_BASE_P(REGNO, MODE) REG_OK_FOR_BASE_P (REGNO)
 118 #endif
 119 \f
 120 /* All reloads of the current insn are recorded here.  See reload.h for
 121    comments.  */
 122 int n_reloads;
 123 struct reload rld[MAX_RELOADS];
 124
 125 /* All the "earlyclobber" operands of the current insn
 126    are recorded here.  */
 127 int n_earlyclobbers;
 128 rtx reload_earlyclobbers[MAX_RECOG_OPERANDS];
 129
 130 int reload_n_operands;
 131
 132 /* Replacing reloads.
 133
 134    If `replace_reloads' is nonzero, then as each reload is recorded
 135    an entry is made for it in the table `replacements'.
 136    Then later `subst_reloads' can look through that table and
 137    perform all the replacements needed.  */
 138
 139 /* Nonzero means record the places to replace.  */
 140 static int replace_reloads;
 141
 142 /* Each replacement is recorded with a structure like this.  */
 143 struct replacement
 144 {
 145   rtx *where;                   /* Location to store in */
 146   rtx *subreg_loc;              /* Location of SUBREG if WHERE is inside
 147                                    a SUBREG; 0 otherwise.  */
 148   int what;                     /* which reload this is for */
 149   enum machine_mode mode;       /* mode it must have */
 150 };
 151
 152 static struct replacement replacements[MAX_RECOG_OPERANDS * ((MAX_REGS_PER_ADDRESS * 2) + 1)];
 153
 154 /* Number of replacements currently recorded.  */
 155 static int n_replacements;
 156
 157 /* Used to track what is modified by an operand.  */
 158 struct decomposition
 159 {
 160   int reg_flag;         /* Nonzero if referencing a register.  */
 161   int safe;             /* Nonzero if this can't conflict with anything.  */
 162   rtx base;             /* Base address for MEM.  */
 163   HOST_WIDE_INT start;  /* Starting offset or register number.  */
 164   HOST_WIDE_INT end;    /* Ending offset or register number.  */
 165 };
 166
 167 #ifdef SECONDARY_MEMORY_NEEDED
 168
 169 /* Save MEMs needed to copy from one class of registers to another.  One MEM
 170    is used per mode, but normally only one or two modes are ever used.
 171
 172    We keep two versions, before and after register elimination.  The one
 173    after register elimination is record separately for each operand.  This
 174    is done in case the address is not valid to be sure that we separately
 175    reload each.  */
 176
 177 static rtx secondary_memlocs[NUM_MACHINE_MODES];
 178 static rtx secondary_memlocs_elim[NUM_MACHINE_MODES][MAX_RECOG_OPERANDS];
 179 #endif
 180
 181 /* The instruction we are doing reloads for;
 182    so we can test whether a register dies in it.  */
 183 static rtx this_insn;
 184
 185 /* Nonzero if this instruction is a user-specified asm with operands.  */
 186 static int this_insn_is_asm;
 187
 188 /* If hard_regs_live_known is nonzero,
 189    we can tell which hard regs are currently live,
 190    at least enough to succeed in choosing dummy reloads.  */
 191 static int hard_regs_live_known;
 192
 193 /* Indexed by hard reg number,
 194    element is nonnegative if hard reg has been spilled.
 195    This vector is passed to `find_reloads' as an argument
 196    and is not changed here.  */
 197 static short *static_reload_reg_p;
 198
 199 /* Set to 1 in subst_reg_equivs if it changes anything.  */
 200 static int subst_reg_equivs_changed;
 201
 202 /* On return from push_reload, holds the reload-number for the OUT
 203    operand, which can be different for that from the input operand.  */
 204 static int output_reloadnum;
 205
 206   /* Compare two RTX's.  */
 207 #define MATCHES(x, y) \
 208  (x == y || (x != 0 && (GET_CODE (x) == REG                             \
 209                         ? GET_CODE (y) == REG && REGNO (x) == REGNO (y) \
 210                         : rtx_equal_p (x, y) && ! side_effects_p (x))))
 211
 212   /* Indicates if two reloads purposes are for similar enough things that we
 213      can merge their reloads.  */
 214 #define MERGABLE_RELOADS(when1, when2, op1, op2) \
 215   ((when1) == RELOAD_OTHER || (when2) == RELOAD_OTHER   \
 216    || ((when1) == (when2) && (op1) == (op2))            \
 217    || ((when1) == RELOAD_FOR_INPUT && (when2) == RELOAD_FOR_INPUT) \
 218    || ((when1) == RELOAD_FOR_OPERAND_ADDRESS            \
 219        && (when2) == RELOAD_FOR_OPERAND_ADDRESS)        \
 220    || ((when1) == RELOAD_FOR_OTHER_ADDRESS              \
 221        && (when2) == RELOAD_FOR_OTHER_ADDRESS))
 222
 223   /* Nonzero if these two reload purposes produce RELOAD_OTHER when merged.  */
 224 #define MERGE_TO_OTHER(when1, when2, op1, op2) \
 225   ((when1) != (when2)                                   \
 226    || ! ((op1) == (op2)                                 \
 227          || (when1) == RELOAD_FOR_INPUT                 \
 228          || (when1) == RELOAD_FOR_OPERAND_ADDRESS       \
 229          || (when1) == RELOAD_FOR_OTHER_ADDRESS))
 230
 231   /* If we are going to reload an address, compute the reload type to
 232      use.  */
 233 #define ADDR_TYPE(type)                                 \
 234   ((type) == RELOAD_FOR_INPUT_ADDRESS                   \
 235    ? RELOAD_FOR_INPADDR_ADDRESS                         \
 236    : ((type) == RELOAD_FOR_OUTPUT_ADDRESS               \
 237       ? RELOAD_FOR_OUTADDR_ADDRESS                      \
 238       : (type)))
 239
 240 #ifdef HAVE_SECONDARY_RELOADS
 241 static int push_secondary_reload PARAMS ((int, rtx, int, int, enum reg_class,
 242                                         enum machine_mode, enum reload_type,
 243                                         enum insn_code *));
 244 #endif
 245 static enum reg_class find_valid_class PARAMS ((enum machine_mode, int,
 246                                                 unsigned int));
 247 static int reload_inner_reg_of_subreg PARAMS ((rtx, enum machine_mode, int));
 248 static void push_replacement    PARAMS ((rtx *, int, enum machine_mode));
 249 static void dup_replacements    PARAMS ((rtx *, rtx *));
 250 static void combine_reloads     PARAMS ((void));
 251 static int find_reusable_reload PARAMS ((rtx *, rtx, enum reg_class,
 252                                        enum reload_type, int, int));
 253 static rtx find_dummy_reload    PARAMS ((rtx, rtx, rtx *, rtx *,
 254                                        enum machine_mode, enum machine_mode,
 255                                        enum reg_class, int, int));
 256 static int hard_reg_set_here_p  PARAMS ((unsigned int, unsigned int, rtx));
 257 static struct decomposition decompose PARAMS ((rtx));
 258 static int immune_p             PARAMS ((rtx, rtx, struct decomposition));
 259 static int alternative_allows_memconst PARAMS ((const char *, int));
 260 static rtx find_reloads_toplev  PARAMS ((rtx, int, enum reload_type, int,
 261                                          int, rtx, int *));
 262 static rtx make_memloc          PARAMS ((rtx, int));
 263 static int find_reloads_address PARAMS ((enum machine_mode, rtx *, rtx, rtx *,
 264                                        int, enum reload_type, int, rtx));
 265 static rtx subst_reg_equivs     PARAMS ((rtx, rtx));
 266 static rtx subst_indexed_address PARAMS ((rtx));
 267 static void update_auto_inc_notes PARAMS ((rtx, int, int));
 268 static int find_reloads_address_1 PARAMS ((enum machine_mode, rtx, int, rtx *,
 269                                          int, enum reload_type,int, rtx));
 270 static void find_reloads_address_part PARAMS ((rtx, rtx *, enum reg_class,
 271                                              enum machine_mode, int,
 272                                              enum reload_type, int));
 273 static rtx find_reloads_subreg_address PARAMS ((rtx, int, int,
 274                                                 enum reload_type, int, rtx));
 275 static void copy_replacements_1 PARAMS ((rtx *, rtx *, int));
 276 static int find_inc_amount      PARAMS ((rtx, rtx));
 277 \f
 278 #ifdef HAVE_SECONDARY_RELOADS
 279
 280 /* Determine if any secondary reloads are needed for loading (if IN_P is
 281    nonzero) or storing (if IN_P is zero) X to or from a reload register of
 282    register class RELOAD_CLASS in mode RELOAD_MODE.  If secondary reloads
 283    are needed, push them.
 284
 285    Return the reload number of the secondary reload we made, or -1 if
 286    we didn't need one.  *PICODE is set to the insn_code to use if we do
 287    need a secondary reload.  */
 288
 289 static int
 290 push_secondary_reload (in_p, x, opnum, optional, reload_class, reload_mode,
 291                        type, picode)
 292      int in_p;
 293      rtx x;
 294      int opnum;
 295      int optional;
 296      enum reg_class reload_class;
 297      enum machine_mode reload_mode;
 298      enum reload_type type;
 299      enum insn_code *picode;
 300 {
 301   enum reg_class class = NO_REGS;
 302   enum machine_mode mode = reload_mode;
 303   enum insn_code icode = CODE_FOR_nothing;
 304   enum reg_class t_class = NO_REGS;
 305   enum machine_mode t_mode = VOIDmode;
 306   enum insn_code t_icode = CODE_FOR_nothing;
 307   enum reload_type secondary_type;
 308   int s_reload, t_reload = -1;
 309
 310   if (type == RELOAD_FOR_INPUT_ADDRESS
 311       || type == RELOAD_FOR_OUTPUT_ADDRESS
 312       || type == RELOAD_FOR_INPADDR_ADDRESS
 313       || type == RELOAD_FOR_OUTADDR_ADDRESS)
 314     secondary_type = type;
 315   else
 316     secondary_type = in_p ? RELOAD_FOR_INPUT_ADDRESS : RELOAD_FOR_OUTPUT_ADDRESS;
 317
 318   *picode = CODE_FOR_nothing;
 319
 320   /* If X is a paradoxical SUBREG, use the inner value to determine both the
 321      mode and object being reloaded.  */
 322   if (GET_CODE (x) == SUBREG
 323       && (GET_MODE_SIZE (GET_MODE (x))
 324           > GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))))
 325     {
 326       x = SUBREG_REG (x);
 327       reload_mode = GET_MODE (x);
 328     }
 329
 330   /* If X is a pseudo-register that has an equivalent MEM (actually, if it
 331      is still a pseudo-register by now, it *must* have an equivalent MEM
 332      but we don't want to assume that), use that equivalent when seeing if
 333      a secondary reload is needed since whether or not a reload is needed
 334      might be sensitive to the form of the MEM.  */
 335
 336   if (GET_CODE (x) == REG && REGNO (x) >= FIRST_PSEUDO_REGISTER
 337       && reg_equiv_mem[REGNO (x)] != 0)
 338     x = reg_equiv_mem[REGNO (x)];
 339
 340 #ifdef SECONDARY_INPUT_RELOAD_CLASS
 341   if (in_p)
 342     class = SECONDARY_INPUT_RELOAD_CLASS (reload_class, reload_mode, x);
 343 #endif
 344
 345 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
 346   if (! in_p)
 347     class = SECONDARY_OUTPUT_RELOAD_CLASS (reload_class, reload_mode, x);
 348 #endif
 349
 350   /* If we don't need any secondary registers, done.  */
 351   if (class == NO_REGS)
 352     return -1;
 353
 354   /* Get a possible insn to use.  If the predicate doesn't accept X, don't
 355      use the insn.  */
 356
 357   icode = (in_p ? reload_in_optab[(int) reload_mode]
 358            : reload_out_optab[(int) reload_mode]);
 359
 360   if (icode != CODE_FOR_nothing
 361       && insn_data[(int) icode].operand[in_p].predicate
 362       && (! (insn_data[(int) icode].operand[in_p].predicate) (x, reload_mode)))
 363     icode = CODE_FOR_nothing;
 364
 365   /* If we will be using an insn, see if it can directly handle the reload
 366      register we will be using.  If it can, the secondary reload is for a
 367      scratch register.  If it can't, we will use the secondary reload for
 368      an intermediate register and require a tertiary reload for the scratch
 369      register.  */
 370
 371   if (icode != CODE_FOR_nothing)
 372     {
 373       /* If IN_P is nonzero, the reload register will be the output in
 374          operand 0.  If IN_P is zero, the reload register will be the input
 375          in operand 1.  Outputs should have an initial "=", which we must
 376          skip.  */
 377
 378       enum reg_class insn_class;
 379
 380       if (insn_data[(int) icode].operand[!in_p].constraint[0] == 0)
 381         insn_class = ALL_REGS;
 382       else
 383         {
 384           const char *insn_constraint
 385             = &insn_data[(int) icode].operand[!in_p].constraint[in_p];
 386           char insn_letter = *insn_constraint;
 387           insn_class
 388             = (insn_letter == 'r' ? GENERAL_REGS
 389                : REG_CLASS_FROM_CONSTRAINT ((unsigned char) insn_letter,
 390                                             insn_constraint));
 391
 392           if (insn_class == NO_REGS)
 393             abort ();
 394           if (in_p
 395               && insn_data[(int) icode].operand[!in_p].constraint[0] != '=')
 396             abort ();
 397         }
 398
 399       /* The scratch register's constraint must start with "=&".  */
 400       if (insn_data[(int) icode].operand[2].constraint[0] != '='
 401           || insn_data[(int) icode].operand[2].constraint[1] != '&')
 402         abort ();
 403
 404       if (reg_class_subset_p (reload_class, insn_class))
 405         mode = insn_data[(int) icode].operand[2].mode;
 406       else
 407         {
 408           const char *t_constraint
 409             = &insn_data[(int) icode].operand[2].constraint[2];
 410           char t_letter = *t_constraint;
 411           class = insn_class;
 412           t_mode = insn_data[(int) icode].operand[2].mode;
 413           t_class = (t_letter == 'r' ? GENERAL_REGS
 414                      : REG_CLASS_FROM_CONSTRAINT ((unsigned char) t_letter,
 415                                                   t_constraint));
 416           t_icode = icode;
 417           icode = CODE_FOR_nothing;
 418         }
 419     }
 420
 421   /* This case isn't valid, so fail.  Reload is allowed to use the same
 422      register for RELOAD_FOR_INPUT_ADDRESS and RELOAD_FOR_INPUT reloads, but
 423      in the case of a secondary register, we actually need two different
 424      registers for correct code.  We fail here to prevent the possibility of
 425      silently generating incorrect code later.
 426
 427      The convention is that secondary input reloads are valid only if the
 428      secondary_class is different from class.  If you have such a case, you
 429      can not use secondary reloads, you must work around the problem some
 430      other way.
 431
 432      Allow this when a reload_in/out pattern is being used.  I.e. assume
 433      that the generated code handles this case.  */
 434
 435   if (in_p && class == reload_class && icode == CODE_FOR_nothing
 436       && t_icode == CODE_FOR_nothing)
 437     abort ();
 438
 439   /* If we need a tertiary reload, see if we have one we can reuse or else
 440      make a new one.  */
 441
 442   if (t_class != NO_REGS)
 443     {
 444       for (t_reload = 0; t_reload < n_reloads; t_reload++)
 445         if (rld[t_reload].secondary_p
 446             && (reg_class_subset_p (t_class, rld[t_reload].class)
 447                 || reg_class_subset_p (rld[t_reload].class, t_class))
 448             && ((in_p && rld[t_reload].inmode == t_mode)
 449                 || (! in_p && rld[t_reload].outmode == t_mode))
 450             && ((in_p && (rld[t_reload].secondary_in_icode
 451                           == CODE_FOR_nothing))
 452                 || (! in_p &&(rld[t_reload].secondary_out_icode
 453                               == CODE_FOR_nothing)))
 454             && (reg_class_size[(int) t_class] == 1 || SMALL_REGISTER_CLASSES)
 455             && MERGABLE_RELOADS (secondary_type,
 456                                  rld[t_reload].when_needed,
 457                                  opnum, rld[t_reload].opnum))
 458           {
 459             if (in_p)
 460               rld[t_reload].inmode = t_mode;
 461             if (! in_p)
 462               rld[t_reload].outmode = t_mode;
 463
 464             if (reg_class_subset_p (t_class, rld[t_reload].class))
 465               rld[t_reload].class = t_class;
 466
 467             rld[t_reload].opnum = MIN (rld[t_reload].opnum, opnum);
 468             rld[t_reload].optional &= optional;
 469             rld[t_reload].secondary_p = 1;
 470             if (MERGE_TO_OTHER (secondary_type, rld[t_reload].when_needed,
 471                                 opnum, rld[t_reload].opnum))
 472               rld[t_reload].when_needed = RELOAD_OTHER;
 473           }
 474
 475       if (t_reload == n_reloads)
 476         {
 477           /* We need to make a new tertiary reload for this register class.  */
 478           rld[t_reload].in = rld[t_reload].out = 0;
 479           rld[t_reload].class = t_class;
 480           rld[t_reload].inmode = in_p ? t_mode : VOIDmode;
 481           rld[t_reload].outmode = ! in_p ? t_mode : VOIDmode;
 482           rld[t_reload].reg_rtx = 0;
 483           rld[t_reload].optional = optional;
 484           rld[t_reload].inc = 0;
 485           /* Maybe we could combine these, but it seems too tricky.  */
 486           rld[t_reload].nocombine = 1;
 487           rld[t_reload].in_reg = 0;
 488           rld[t_reload].out_reg = 0;
 489           rld[t_reload].opnum = opnum;
 490           rld[t_reload].when_needed = secondary_type;
 491           rld[t_reload].secondary_in_reload = -1;
 492           rld[t_reload].secondary_out_reload = -1;
 493           rld[t_reload].secondary_in_icode = CODE_FOR_nothing;
 494           rld[t_reload].secondary_out_icode = CODE_FOR_nothing;
 495           rld[t_reload].secondary_p = 1;
 496
 497           n_reloads++;
 498         }
 499     }
 500
 501   /* See if we can reuse an existing secondary reload.  */
 502   for (s_reload = 0; s_reload < n_reloads; s_reload++)
 503     if (rld[s_reload].secondary_p
 504         && (reg_class_subset_p (class, rld[s_reload].class)
 505             || reg_class_subset_p (rld[s_reload].class, class))
 506         && ((in_p && rld[s_reload].inmode == mode)
 507             || (! in_p && rld[s_reload].outmode == mode))
 508         && ((in_p && rld[s_reload].secondary_in_reload == t_reload)
 509             || (! in_p && rld[s_reload].secondary_out_reload == t_reload))
 510         && ((in_p && rld[s_reload].secondary_in_icode == t_icode)
 511             || (! in_p && rld[s_reload].secondary_out_icode == t_icode))
 512         && (reg_class_size[(int) class] == 1 || SMALL_REGISTER_CLASSES)
 513         && MERGABLE_RELOADS (secondary_type, rld[s_reload].when_needed,
 514                              opnum, rld[s_reload].opnum))
 515       {
 516         if (in_p)
 517           rld[s_reload].inmode = mode;
 518         if (! in_p)
 519           rld[s_reload].outmode = mode;
 520
 521         if (reg_class_subset_p (class, rld[s_reload].class))
 522           rld[s_reload].class = class;
 523
 524         rld[s_reload].opnum = MIN (rld[s_reload].opnum, opnum);
 525         rld[s_reload].optional &= optional;
 526         rld[s_reload].secondary_p = 1;
 527         if (MERGE_TO_OTHER (secondary_type, rld[s_reload].when_needed,
 528                             opnum, rld[s_reload].opnum))
 529           rld[s_reload].when_needed = RELOAD_OTHER;
 530       }
 531
 532   if (s_reload == n_reloads)
 533     {
 534 #ifdef SECONDARY_MEMORY_NEEDED
 535       /* If we need a memory location to copy between the two reload regs,
 536          set it up now.  Note that we do the input case before making
 537          the reload and the output case after.  This is due to the
 538          way reloads are output.  */
 539
 540       if (in_p && icode == CODE_FOR_nothing
 541           && SECONDARY_MEMORY_NEEDED (class, reload_class, mode))
 542         {
 543           get_secondary_mem (x, reload_mode, opnum, type);
 544
 545           /* We may have just added new reloads.  Make sure we add
 546              the new reload at the end.  */
 547           s_reload = n_reloads;
 548         }
 549 #endif
 550
 551       /* We need to make a new secondary reload for this register class.  */
 552       rld[s_reload].in = rld[s_reload].out = 0;
 553       rld[s_reload].class = class;
 554
 555       rld[s_reload].inmode = in_p ? mode : VOIDmode;
 556       rld[s_reload].outmode = ! in_p ? mode : VOIDmode;
 557       rld[s_reload].reg_rtx = 0;
 558       rld[s_reload].optional = optional;
 559       rld[s_reload].inc = 0;
 560       /* Maybe we could combine these, but it seems too tricky.  */
 561       rld[s_reload].nocombine = 1;
 562       rld[s_reload].in_reg = 0;
 563       rld[s_reload].out_reg = 0;
 564       rld[s_reload].opnum = opnum;
 565       rld[s_reload].when_needed = secondary_type;
 566       rld[s_reload].secondary_in_reload = in_p ? t_reload : -1;
 567       rld[s_reload].secondary_out_reload = ! in_p ? t_reload : -1;
 568       rld[s_reload].secondary_in_icode = in_p ? t_icode : CODE_FOR_nothing;
 569       rld[s_reload].secondary_out_icode
 570         = ! in_p ? t_icode : CODE_FOR_nothing;
 571       rld[s_reload].secondary_p = 1;
 572
 573       n_reloads++;
 574
 575 #ifdef SECONDARY_MEMORY_NEEDED
 576       if (! in_p && icode == CODE_FOR_nothing
 577           && SECONDARY_MEMORY_NEEDED (reload_class, class, mode))
 578         get_secondary_mem (x, mode, opnum, type);
 579 #endif
 580     }
 581
 582   *picode = icode;
 583   return s_reload;
 584 }
 585 #endif /* HAVE_SECONDARY_RELOADS */
 586 \f
 587 #ifdef SECONDARY_MEMORY_NEEDED
 588
 589 /* Return a memory location that will be used to copy X in mode MODE.
 590    If we haven't already made a location for this mode in this insn,
 591    call find_reloads_address on the location being returned.  */
 592
 593 rtx
 594 get_secondary_mem (x, mode, opnum, type)
 595      rtx x ATTRIBUTE_UNUSED;
 596      enum machine_mode mode;
 597      int opnum;
 598      enum reload_type type;
 599 {
 600   rtx loc;
 601   int mem_valid;
 602
 603   /* By default, if MODE is narrower than a word, widen it to a word.
 604      This is required because most machines that require these memory
 605      locations do not support short load and stores from all registers
 606      (e.g., FP registers).  */
 607
 608 #ifdef SECONDARY_MEMORY_NEEDED_MODE
 609   mode = SECONDARY_MEMORY_NEEDED_MODE (mode);
 610 #else
 611   if (GET_MODE_BITSIZE (mode) < BITS_PER_WORD && INTEGRAL_MODE_P (mode))
 612     mode = mode_for_size (BITS_PER_WORD, GET_MODE_CLASS (mode), 0);
 613 #endif
 614
 615   /* If we already have made a MEM for this operand in MODE, return it.  */
 616   if (secondary_memlocs_elim[(int) mode][opnum] != 0)
 617     return secondary_memlocs_elim[(int) mode][opnum];
 618
 619   /* If this is the first time we've tried to get a MEM for this mode,
 620      allocate a new one.  `something_changed' in reload will get set
 621      by noticing that the frame size has changed.  */
 622
 623   if (secondary_memlocs[(int) mode] == 0)
 624     {
 625 #ifdef SECONDARY_MEMORY_NEEDED_RTX
 626       secondary_memlocs[(int) mode] = SECONDARY_MEMORY_NEEDED_RTX (mode);
 627 #else
 628       secondary_memlocs[(int) mode]
 629         = assign_stack_local (mode, GET_MODE_SIZE (mode), 0);
 630 #endif
 631     }
 632
 633   /* Get a version of the address doing any eliminations needed.  If that
 634      didn't give us a new MEM, make a new one if it isn't valid.  */
 635
 636   loc = eliminate_regs (secondary_memlocs[(int) mode], VOIDmode, NULL_RTX);
 637   mem_valid = strict_memory_address_p (mode, XEXP (loc, 0));
 638
 639   if (! mem_valid && loc == secondary_memlocs[(int) mode])
 640     loc = copy_rtx (loc);
 641
 642   /* The only time the call below will do anything is if the stack
 643      offset is too large.  In that case IND_LEVELS doesn't matter, so we
 644      can just pass a zero.  Adjust the type to be the address of the
 645      corresponding object.  If the address was valid, save the eliminated
 646      address.  If it wasn't valid, we need to make a reload each time, so
 647      don't save it.  */
 648
 649   if (! mem_valid)
 650     {
 651       type =  (type == RELOAD_FOR_INPUT ? RELOAD_FOR_INPUT_ADDRESS
 652                : type == RELOAD_FOR_OUTPUT ? RELOAD_FOR_OUTPUT_ADDRESS
 653                : RELOAD_OTHER);
 654
 655       find_reloads_address (mode, &loc, XEXP (loc, 0), &XEXP (loc, 0),
 656                             opnum, type, 0, 0);
 657     }
 658
 659   secondary_memlocs_elim[(int) mode][opnum] = loc;
 660   return loc;
 661 }
 662
 663 /* Clear any secondary memory locations we've made.  */
 664
 665 void
 666 clear_secondary_mem ()
 667 {
 668   memset ((char *) secondary_memlocs, 0, sizeof secondary_memlocs);
 669 }
 670 #endif /* SECONDARY_MEMORY_NEEDED */
 671 \f
 672 /* Find the largest class for which every register number plus N is valid in
 673    M1 (if in range) and is cheap to move into REGNO.
 674    Abort if no such class exists.  */
 675
 676 static enum reg_class
 677 find_valid_class (m1, n, dest_regno)
 678      enum machine_mode m1 ATTRIBUTE_UNUSED;
 679      int n;
 680      unsigned int dest_regno ATTRIBUTE_UNUSED;
 681 {
 682   int best_cost = -1;
 683   int class;
 684   int regno;
 685   enum reg_class best_class = NO_REGS;
 686   enum reg_class dest_class ATTRIBUTE_UNUSED = REGNO_REG_CLASS (dest_regno);
 687   unsigned int best_size = 0;
 688   int cost;
 689
 690   for (class = 1; class < N_REG_CLASSES; class++)
 691     {
 692       int bad = 0;
 693       for (regno = 0; regno < FIRST_PSEUDO_REGISTER && ! bad; regno++)
 694         if (TEST_HARD_REG_BIT (reg_class_contents[class], regno)
 695             && TEST_HARD_REG_BIT (reg_class_contents[class], regno + n)
 696             && ! HARD_REGNO_MODE_OK (regno + n, m1))
 697           bad = 1;
 698
 699       if (bad)
 700         continue;
 701       cost = REGISTER_MOVE_COST (m1, class, dest_class);
 702
 703       if ((reg_class_size[class] > best_size
 704            && (best_cost < 0 || best_cost >= cost))
 705           || best_cost > cost)
 706         {
 707           best_class = class;
 708           best_size = reg_class_size[class];
 709           best_cost = REGISTER_MOVE_COST (m1, class, dest_class);
 710         }
 711     }
 712
 713   if (best_size == 0)
 714     abort ();
 715
 716   return best_class;
 717 }
 718 \f
 719 /* Return the number of a previously made reload that can be combined with
 720    a new one, or n_reloads if none of the existing reloads can be used.
 721    OUT, CLASS, TYPE and OPNUM are the same arguments as passed to
 722    push_reload, they determine the kind of the new reload that we try to
 723    combine.  P_IN points to the corresponding value of IN, which can be
 724    modified by this function.
 725    DONT_SHARE is nonzero if we can't share any input-only reload for IN.  */
 726
 727 static int
 728 find_reusable_reload (p_in, out, class, type, opnum, dont_share)
 729      rtx *p_in, out;
 730      enum reg_class class;
 731      enum reload_type type;
 732      int opnum, dont_share;
 733 {
 734   rtx in = *p_in;
 735   int i;
 736   /* We can't merge two reloads if the output of either one is
 737      earlyclobbered.  */
 738
 739   if (earlyclobber_operand_p (out))
 740     return n_reloads;
 741
 742   /* We can use an existing reload if the class is right
 743      and at least one of IN and OUT is a match
 744      and the other is at worst neutral.
 745      (A zero compared against anything is neutral.)
 746
 747      If SMALL_REGISTER_CLASSES, don't use existing reloads unless they are
 748      for the same thing since that can cause us to need more reload registers
 749      than we otherwise would.  */
 750
 751   for (i = 0; i < n_reloads; i++)
 752     if ((reg_class_subset_p (class, rld[i].class)
 753          || reg_class_subset_p (rld[i].class, class))
 754         /* If the existing reload has a register, it must fit our class.  */
 755         && (rld[i].reg_rtx == 0
 756             || TEST_HARD_REG_BIT (reg_class_contents[(int) class],
 757                                   true_regnum (rld[i].reg_rtx)))
 758         && ((in != 0 && MATCHES (rld[i].in, in) && ! dont_share
 759              && (out == 0 || rld[i].out == 0 || MATCHES (rld[i].out, out)))
 760             || (out != 0 && MATCHES (rld[i].out, out)
 761                 && (in == 0 || rld[i].in == 0 || MATCHES (rld[i].in, in))))
 762         && (rld[i].out == 0 || ! earlyclobber_operand_p (rld[i].out))
 763         && (reg_class_size[(int) class] == 1 || SMALL_REGISTER_CLASSES)
 764         && MERGABLE_RELOADS (type, rld[i].when_needed, opnum, rld[i].opnum))
 765       return i;
 766
 767   /* Reloading a plain reg for input can match a reload to postincrement
 768      that reg, since the postincrement's value is the right value.
 769      Likewise, it can match a preincrement reload, since we regard
 770      the preincrementation as happening before any ref in this insn
 771      to that register.  */
 772   for (i = 0; i < n_reloads; i++)
 773     if ((reg_class_subset_p (class, rld[i].class)
 774          || reg_class_subset_p (rld[i].class, class))
 775         /* If the existing reload has a register, it must fit our
 776            class.  */
 777         && (rld[i].reg_rtx == 0
 778             || TEST_HARD_REG_BIT (reg_class_contents[(int) class],
 779                                   true_regnum (rld[i].reg_rtx)))
 780         && out == 0 && rld[i].out == 0 && rld[i].in != 0
 781         && ((GET_CODE (in) == REG
 782              && GET_RTX_CLASS (GET_CODE (rld[i].in)) == 'a'
 783              && MATCHES (XEXP (rld[i].in, 0), in))
 784             || (GET_CODE (rld[i].in) == REG
 785                 && GET_RTX_CLASS (GET_CODE (in)) == 'a'
 786                 && MATCHES (XEXP (in, 0), rld[i].in)))
 787         && (rld[i].out == 0 || ! earlyclobber_operand_p (rld[i].out))
 788         && (reg_class_size[(int) class] == 1 || SMALL_REGISTER_CLASSES)
 789         && MERGABLE_RELOADS (type, rld[i].when_needed,
 790                              opnum, rld[i].opnum))
 791       {
 792         /* Make sure reload_in ultimately has the increment,
 793            not the plain register.  */
 794         if (GET_CODE (in) == REG)
 795           *p_in = rld[i].in;
 796         return i;
 797       }
 798   return n_reloads;
 799 }
 800
 801 /* Return nonzero if X is a SUBREG which will require reloading of its
 802    SUBREG_REG expression.  */
 803
 804 static int
 805 reload_inner_reg_of_subreg (x, mode, output)
 806      rtx x;
 807      enum machine_mode mode;
 808      int output;
 809 {
 810   rtx inner;
 811
 812   /* Only SUBREGs are problematical.  */
 813   if (GET_CODE (x) != SUBREG)
 814     return 0;
 815
 816   inner = SUBREG_REG (x);
 817
 818   /* If INNER is a constant or PLUS, then INNER must be reloaded.  */
 819   if (CONSTANT_P (inner) || GET_CODE (inner) == PLUS)
 820     return 1;
 821
 822   /* If INNER is not a hard register, then INNER will not need to
 823      be reloaded.  */
 824   if (GET_CODE (inner) != REG
 825       || REGNO (inner) >= FIRST_PSEUDO_REGISTER)
 826     return 0;
 827
 828   /* If INNER is not ok for MODE, then INNER will need reloading.  */
 829   if (! HARD_REGNO_MODE_OK (subreg_regno (x), mode))
 830     return 1;
 831
 832   /* If the outer part is a word or smaller, INNER larger than a
 833      word and the number of regs for INNER is not the same as the
 834      number of words in INNER, then INNER will need reloading.  */
 835   return (GET_MODE_SIZE (mode) <= UNITS_PER_WORD
 836           && output
 837           && GET_MODE_SIZE (GET_MODE (inner)) > UNITS_PER_WORD
 838           && ((GET_MODE_SIZE (GET_MODE (inner)) / UNITS_PER_WORD)
 839               != (int) HARD_REGNO_NREGS (REGNO (inner), GET_MODE (inner))));
 840 }
 841
 842 /* Record one reload that needs to be performed.
 843    IN is an rtx saying where the data are to be found before this instruction.
 844    OUT says where they must be stored after the instruction.
 845    (IN is zero for data not read, and OUT is zero for data not written.)
 846    INLOC and OUTLOC point to the places in the instructions where
 847    IN and OUT were found.
 848    If IN and OUT are both nonzero, it means the same register must be used
 849    to reload both IN and OUT.
 850
 851    CLASS is a register class required for the reloaded data.
 852    INMODE is the machine mode that the instruction requires
 853    for the reg that replaces IN and OUTMODE is likewise for OUT.
 854
 855    If IN is zero, then OUT's location and mode should be passed as
 856    INLOC and INMODE.
 857
 858    STRICT_LOW is the 1 if there is a containing STRICT_LOW_PART rtx.
 859
 860    OPTIONAL nonzero means this reload does not need to be performed:
 861    it can be discarded if that is more convenient.
 862
 863    OPNUM and TYPE say what the purpose of this reload is.
 864
 865    The return value is the reload-number for this reload.
 866
 867    If both IN and OUT are nonzero, in some rare cases we might
 868    want to make two separate reloads.  (Actually we never do this now.)
 869    Therefore, the reload-number for OUT is stored in
 870    output_reloadnum when we return; the return value applies to IN.
 871    Usually (presently always), when IN and OUT are nonzero,
 872    the two reload-numbers are equal, but the caller should be careful to
 873    distinguish them.  */
 874
 875 int
 876 push_reload (in, out, inloc, outloc, class,
 877              inmode, outmode, strict_low, optional, opnum, type)
 878      rtx in, out;
 879      rtx *inloc, *outloc;
 880      enum reg_class class;
 881      enum machine_mode inmode, outmode;
 882      int strict_low;
 883      int optional;
 884      int opnum;
 885      enum reload_type type;
 886 {
 887   int i;
 888   int dont_share = 0;
 889   int dont_remove_subreg = 0;
 890   rtx *in_subreg_loc = 0, *out_subreg_loc = 0;
 891   int secondary_in_reload = -1, secondary_out_reload = -1;
 892   enum insn_code secondary_in_icode = CODE_FOR_nothing;
 893   enum insn_code secondary_out_icode = CODE_FOR_nothing;
 894
 895   /* INMODE and/or OUTMODE could be VOIDmode if no mode
 896      has been specified for the operand.  In that case,
 897      use the operand's mode as the mode to reload.  */
 898   if (inmode == VOIDmode && in != 0)
 899     inmode = GET_MODE (in);
 900   if (outmode == VOIDmode && out != 0)
 901     outmode = GET_MODE (out);
 902
 903   /* If IN is a pseudo register everywhere-equivalent to a constant, and
 904      it is not in a hard register, reload straight from the constant,
 905      since we want to get rid of such pseudo registers.
 906      Often this is done earlier, but not always in find_reloads_address.  */
 907   if (in != 0 && GET_CODE (in) == REG)
 908     {
 909       int regno = REGNO (in);
 910
 911       if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
 912           && reg_equiv_constant[regno] != 0)
 913         in = reg_equiv_constant[regno];
 914     }
 915
 916   /* Likewise for OUT.  Of course, OUT will never be equivalent to
 917      an actual constant, but it might be equivalent to a memory location
 918      (in the case of a parameter).  */
 919   if (out != 0 && GET_CODE (out) == REG)
 920     {
 921       int regno = REGNO (out);
 922
 923       if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
 924           && reg_equiv_constant[regno] != 0)
 925         out = reg_equiv_constant[regno];
 926     }
 927
 928   /* If we have a read-write operand with an address side-effect,
 929      change either IN or OUT so the side-effect happens only once.  */
 930   if (in != 0 && out != 0 && GET_CODE (in) == MEM && rtx_equal_p (in, out))
 931     switch (GET_CODE (XEXP (in, 0)))
 932       {
 933       case POST_INC: case POST_DEC:   case POST_MODIFY:
 934         in = replace_equiv_address_nv (in, XEXP (XEXP (in, 0), 0));
 935         break;
 936
 937       case PRE_INC: case PRE_DEC: case PRE_MODIFY:
 938         out = replace_equiv_address_nv (out, XEXP (XEXP (out, 0), 0));
 939         break;
 940
 941       default:
 942         break;
 943       }
 944
 945   /* If we are reloading a (SUBREG constant ...), really reload just the
 946      inside expression in its own mode.  Similarly for (SUBREG (PLUS ...)).
 947      If we have (SUBREG:M1 (MEM:M2 ...) ...) (or an inner REG that is still
 948      a pseudo and hence will become a MEM) with M1 wider than M2 and the
 949      register is a pseudo, also reload the inside expression.
 950      For machines that extend byte loads, do this for any SUBREG of a pseudo
 951      where both M1 and M2 are a word or smaller, M1 is wider than M2, and
 952      M2 is an integral mode that gets extended when loaded.
 953      Similar issue for (SUBREG:M1 (REG:M2 ...) ...) for a hard register R where
 954      either M1 is not valid for R or M2 is wider than a word but we only
 955      need one word to store an M2-sized quantity in R.
 956      (However, if OUT is nonzero, we need to reload the reg *and*
 957      the subreg, so do nothing here, and let following statement handle it.)
 958
 959      Note that the case of (SUBREG (CONST_INT...)...) is handled elsewhere;
 960      we can't handle it here because CONST_INT does not indicate a mode.
 961
 962      Similarly, we must reload the inside expression if we have a
 963      STRICT_LOW_PART (presumably, in == out in the cas).
 964
 965      Also reload the inner expression if it does not require a secondary
 966      reload but the SUBREG does.
 967
 968      Finally, reload the inner expression if it is a register that is in
 969      the class whose registers cannot be referenced in a different size
 970      and M1 is not the same size as M2.  If subreg_lowpart_p is false, we
 971      cannot reload just the inside since we might end up with the wrong
 972      register class.  But if it is inside a STRICT_LOW_PART, we have
 973      no choice, so we hope we do get the right register class there.  */
 974
 975   if (in != 0 && GET_CODE (in) == SUBREG
 976       && (subreg_lowpart_p (in) || strict_low)
 977 #ifdef CANNOT_CHANGE_MODE_CLASS
 978       && !reg_classes_intersect_p
 979            (class, CANNOT_CHANGE_MODE_CLASS (GET_MODE (SUBREG_REG (in)),
 980                                              inmode))
 981 #endif
 982       && (CONSTANT_P (SUBREG_REG (in))
 983           || GET_CODE (SUBREG_REG (in)) == PLUS
 984           || strict_low
 985           || (((GET_CODE (SUBREG_REG (in)) == REG
 986                 && REGNO (SUBREG_REG (in)) >= FIRST_PSEUDO_REGISTER)
 987                || GET_CODE (SUBREG_REG (in)) == MEM)
 988               && ((GET_MODE_SIZE (inmode)
 989                    > GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))))
 990 #ifdef LOAD_EXTEND_OP
 991                   || (GET_MODE_SIZE (inmode) <= UNITS_PER_WORD
 992                       && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
 993                           <= UNITS_PER_WORD)
 994                       && (GET_MODE_SIZE (inmode)
 995                           > GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))))
 996                       && INTEGRAL_MODE_P (GET_MODE (SUBREG_REG (in)))
 997                       && LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (in))) != NIL)
 998 #endif
 999 #ifdef WORD_REGISTER_OPERATIONS
1000                   || ((GET_MODE_SIZE (inmode)
1001                        < GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))))
1002                       && ((GET_MODE_SIZE (inmode) - 1) / UNITS_PER_WORD ==
1003                           ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))) - 1)
1004                            / UNITS_PER_WORD)))
1005 #endif
1006                   ))
1007           || (GET_CODE (SUBREG_REG (in)) == REG
1008               && REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER
1009               /* The case where out is nonzero
1010                  is handled differently in the following statement.  */
1011               && (out == 0 || subreg_lowpart_p (in))
1012               && ((GET_MODE_SIZE (inmode) <= UNITS_PER_WORD
1013                    && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
1014                        > UNITS_PER_WORD)
1015                    && ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
1016                         / UNITS_PER_WORD)
1017                        != (int) HARD_REGNO_NREGS (REGNO (SUBREG_REG (in)),
1018                                                   GET_MODE (SUBREG_REG (in)))))
1019                   || ! HARD_REGNO_MODE_OK (subreg_regno (in), inmode)))
1020 #ifdef SECONDARY_INPUT_RELOAD_CLASS
1021           || (SECONDARY_INPUT_RELOAD_CLASS (class, inmode, in) != NO_REGS
1022               && (SECONDARY_INPUT_RELOAD_CLASS (class,
1023                                                 GET_MODE (SUBREG_REG (in)),
1024                                                 SUBREG_REG (in))
1025                   == NO_REGS))
1026 #endif
1027 #ifdef CANNOT_CHANGE_MODE_CLASS
1028           || (GET_CODE (SUBREG_REG (in)) == REG
1029               && REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER
1030               && REG_CANNOT_CHANGE_MODE_P
1031               (REGNO (SUBREG_REG (in)), GET_MODE (SUBREG_REG (in)), inmode))
1032 #endif
1033           ))
1034     {
1035       in_subreg_loc = inloc;
1036       inloc = &SUBREG_REG (in);
1037       in = *inloc;
1038 #if ! defined (LOAD_EXTEND_OP) && ! defined (WORD_REGISTER_OPERATIONS)
1039       if (GET_CODE (in) == MEM)
1040         /* This is supposed to happen only for paradoxical subregs made by
1041            combine.c.  (SUBREG (MEM)) isn't supposed to occur other ways.  */
1042         if (GET_MODE_SIZE (GET_MODE (in)) > GET_MODE_SIZE (inmode))
1043           abort ();
1044 #endif
1045       inmode = GET_MODE (in);
1046     }
1047
1048   /* Similar issue for (SUBREG:M1 (REG:M2 ...) ...) for a hard register R where
1049      either M1 is not valid for R or M2 is wider than a word but we only
1050      need one word to store an M2-sized quantity in R.
1051
1052      However, we must reload the inner reg *as well as* the subreg in
1053      that case.  */
1054
1055   /* Similar issue for (SUBREG constant ...) if it was not handled by the
1056      code above.  This can happen if SUBREG_BYTE != 0.  */
1057
1058   if (in != 0 && reload_inner_reg_of_subreg (in, inmode, 0))
1059     {
1060       enum reg_class in_class = class;
1061
1062       if (GET_CODE (SUBREG_REG (in)) == REG)
1063         in_class
1064           = find_valid_class (inmode,
1065                               subreg_regno_offset (REGNO (SUBREG_REG (in)),
1066                                                    GET_MODE (SUBREG_REG (in)),
1067                                                    SUBREG_BYTE (in),
1068                                                    GET_MODE (in)),
1069                               REGNO (SUBREG_REG (in)));
1070
1071       /* This relies on the fact that emit_reload_insns outputs the
1072          instructions for input reloads of type RELOAD_OTHER in the same
1073          order as the reloads.  Thus if the outer reload is also of type
1074          RELOAD_OTHER, we are guaranteed that this inner reload will be
1075          output before the outer reload.  */
1076       push_reload (SUBREG_REG (in), NULL_RTX, &SUBREG_REG (in), (rtx *) 0,
1077                    in_class, VOIDmode, VOIDmode, 0, 0, opnum, type);
1078       dont_remove_subreg = 1;
1079     }
1080
1081   /* Similarly for paradoxical and problematical SUBREGs on the output.
1082      Note that there is no reason we need worry about the previous value
1083      of SUBREG_REG (out); even if wider than out,
1084      storing in a subreg is entitled to clobber it all
1085      (except in the case of STRICT_LOW_PART,
1086      and in that case the constraint should label it input-output.)  */
1087   if (out != 0 && GET_CODE (out) == SUBREG
1088       && (subreg_lowpart_p (out) || strict_low)
1089 #ifdef CANNOT_CHANGE_MODE_CLASS
1090       && !reg_classes_intersect_p
1091             (class, CANNOT_CHANGE_MODE_CLASS (GET_MODE (SUBREG_REG (out)),
1092                                               outmode))
1093 #endif
1094       && (CONSTANT_P (SUBREG_REG (out))
1095           || strict_low
1096           || (((GET_CODE (SUBREG_REG (out)) == REG
1097                 && REGNO (SUBREG_REG (out)) >= FIRST_PSEUDO_REGISTER)
1098                || GET_CODE (SUBREG_REG (out)) == MEM)
1099               && ((GET_MODE_SIZE (outmode)
1100                    > GET_MODE_SIZE (GET_MODE (SUBREG_REG (out))))
1101 #ifdef WORD_REGISTER_OPERATIONS
1102                   || ((GET_MODE_SIZE (outmode)
1103                        < GET_MODE_SIZE (GET_MODE (SUBREG_REG (out))))
1104                       && ((GET_MODE_SIZE (outmode) - 1) / UNITS_PER_WORD ==
1105                           ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (out))) - 1)
1106                            / UNITS_PER_WORD)))
1107 #endif
1108                   ))
1109           || (GET_CODE (SUBREG_REG (out)) == REG
1110               && REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER
1111               && ((GET_MODE_SIZE (outmode) <= UNITS_PER_WORD
1112                    && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (out)))
1113                        > UNITS_PER_WORD)
1114                    && ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (out)))
1115                         / UNITS_PER_WORD)
1116                        != (int) HARD_REGNO_NREGS (REGNO (SUBREG_REG (out)),
1117                                                   GET_MODE (SUBREG_REG (out)))))
1118                   || ! HARD_REGNO_MODE_OK (subreg_regno (out), outmode)))
1119 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
1120           || (SECONDARY_OUTPUT_RELOAD_CLASS (class, outmode, out) != NO_REGS
1121               && (SECONDARY_OUTPUT_RELOAD_CLASS (class,
1122                                                  GET_MODE (SUBREG_REG (out)),
1123                                                  SUBREG_REG (out))
1124                   == NO_REGS))
1125 #endif
1126 #ifdef CANNOT_CHANGE_MODE_CLASS
1127           || (GET_CODE (SUBREG_REG (out)) == REG
1128               && REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER
1129               && REG_CANNOT_CHANGE_MODE_P (REGNO (SUBREG_REG (out)),
1130                                            GET_MODE (SUBREG_REG (out)),
1131                                            outmode))
1132 #endif
1133           ))
1134     {
1135       out_subreg_loc = outloc;
1136       outloc = &SUBREG_REG (out);
1137       out = *outloc;
1138 #if ! defined (LOAD_EXTEND_OP) && ! defined (WORD_REGISTER_OPERATIONS)
1139       if (GET_CODE (out) == MEM
1140           && GET_MODE_SIZE (GET_MODE (out)) > GET_MODE_SIZE (outmode))
1141         abort ();
1142 #endif
1143       outmode = GET_MODE (out);
1144     }
1145
1146   /* Similar issue for (SUBREG:M1 (REG:M2 ...) ...) for a hard register R where
1147      either M1 is not valid for R or M2 is wider than a word but we only
1148      need one word to store an M2-sized quantity in R.
1149
1150      However, we must reload the inner reg *as well as* the subreg in
1151      that case.  In this case, the inner reg is an in-out reload.  */
1152
1153   if (out != 0 && reload_inner_reg_of_subreg (out, outmode, 1))
1154     {
1155       /* This relies on the fact that emit_reload_insns outputs the
1156          instructions for output reloads of type RELOAD_OTHER in reverse
1157          order of the reloads.  Thus if the outer reload is also of type
1158          RELOAD_OTHER, we are guaranteed that this inner reload will be
1159          output after the outer reload.  */
1160       dont_remove_subreg = 1;
1161       push_reload (SUBREG_REG (out), SUBREG_REG (out), &SUBREG_REG (out),
1162                    &SUBREG_REG (out),
1163                    find_valid_class (outmode,
1164                                      subreg_regno_offset (REGNO (SUBREG_REG (out)),
1165                                                           GET_MODE (SUBREG_REG (out)),
1166                                                           SUBREG_BYTE (out),
1167                                                           GET_MODE (out)),
1168                                      REGNO (SUBREG_REG (out))),
1169                    VOIDmode, VOIDmode, 0, 0,
1170                    opnum, RELOAD_OTHER);
1171     }
1172
1173   /* If IN appears in OUT, we can't share any input-only reload for IN.  */
1174   if (in != 0 && out != 0 && GET_CODE (out) == MEM
1175       && (GET_CODE (in) == REG || GET_CODE (in) == MEM)
1176       && reg_overlap_mentioned_for_reload_p (in, XEXP (out, 0)))
1177     dont_share = 1;
1178
1179   /* If IN is a SUBREG of a hard register, make a new REG.  This
1180      simplifies some of the cases below.  */
1181
1182   if (in != 0 && GET_CODE (in) == SUBREG && GET_CODE (SUBREG_REG (in)) == REG
1183       && REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER
1184       && ! dont_remove_subreg)
1185     in = gen_rtx_REG (GET_MODE (in), subreg_regno (in));
1186
1187   /* Similarly for OUT.  */
1188   if (out != 0 && GET_CODE (out) == SUBREG
1189       && GET_CODE (SUBREG_REG (out)) == REG
1190       && REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER
1191       && ! dont_remove_subreg)
1192     out = gen_rtx_REG (GET_MODE (out), subreg_regno (out));
1193
1194   /* Narrow down the class of register wanted if that is
1195      desirable on this machine for efficiency.  */
1196   if (in != 0)
1197     class = PREFERRED_RELOAD_CLASS (in, class);
1198
1199   /* Output reloads may need analogous treatment, different in detail.  */
1200 #ifdef PREFERRED_OUTPUT_RELOAD_CLASS
1201   if (out != 0)
1202     class = PREFERRED_OUTPUT_RELOAD_CLASS (out, class);
1203 #endif
1204
1205   /* Make sure we use a class that can handle the actual pseudo
1206      inside any subreg.  For example, on the 386, QImode regs
1207      can appear within SImode subregs.  Although GENERAL_REGS
1208      can handle SImode, QImode needs a smaller class.  */
1209 #ifdef LIMIT_RELOAD_CLASS
1210   if (in_subreg_loc)
1211     class = LIMIT_RELOAD_CLASS (inmode, class);
1212   else if (in != 0 && GET_CODE (in) == SUBREG)
1213     class = LIMIT_RELOAD_CLASS (GET_MODE (SUBREG_REG (in)), class);
1214
1215   if (out_subreg_loc)
1216     class = LIMIT_RELOAD_CLASS (outmode, class);
1217   if (out != 0 && GET_CODE (out) == SUBREG)
1218     class = LIMIT_RELOAD_CLASS (GET_MODE (SUBREG_REG (out)), class);
1219 #endif
1220
1221   /* Verify that this class is at least possible for the mode that
1222      is specified.  */
1223   if (this_insn_is_asm)
1224     {
1225       enum machine_mode mode;
1226       if (GET_MODE_SIZE (inmode) > GET_MODE_SIZE (outmode))
1227         mode = inmode;
1228       else
1229         mode = outmode;
1230       if (mode == VOIDmode)
1231         {
1232           error_for_asm (this_insn, "cannot reload integer constant operand in `asm'");
1233           mode = word_mode;
1234           if (in != 0)
1235             inmode = word_mode;
1236           if (out != 0)
1237             outmode = word_mode;
1238         }
1239       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1240         if (HARD_REGNO_MODE_OK (i, mode)
1241             && TEST_HARD_REG_BIT (reg_class_contents[(int) class], i))
1242           {
1243             int nregs = HARD_REGNO_NREGS (i, mode);
1244
1245             int j;
1246             for (j = 1; j < nregs; j++)
1247               if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class], i + j))
1248                 break;
1249             if (j == nregs)
1250               break;
1251           }
1252       if (i == FIRST_PSEUDO_REGISTER)
1253         {
1254           error_for_asm (this_insn, "impossible register constraint in `asm'");
1255           class = ALL_REGS;
1256         }
1257     }
1258
1259   /* Optional output reloads are always OK even if we have no register class,
1260      since the function of these reloads is only to have spill_reg_store etc.
1261      set, so that the storing insn can be deleted later.  */
1262   if (class == NO_REGS
1263       && (optional == 0 || type != RELOAD_FOR_OUTPUT))
1264     abort ();
1265
1266   i = find_reusable_reload (&in, out, class, type, opnum, dont_share);
1267
1268   if (i == n_reloads)
1269     {
1270       /* See if we need a secondary reload register to move between CLASS
1271          and IN or CLASS and OUT.  Get the icode and push any required reloads
1272          needed for each of them if so.  */
1273
1274 #ifdef SECONDARY_INPUT_RELOAD_CLASS
1275       if (in != 0)
1276         secondary_in_reload
1277           = push_secondary_reload (1, in, opnum, optional, class, inmode, type,
1278                                    &secondary_in_icode);
1279 #endif
1280
1281 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
1282       if (out != 0 && GET_CODE (out) != SCRATCH)
1283         secondary_out_reload
1284           = push_secondary_reload (0, out, opnum, optional, class, outmode,
1285                                    type, &secondary_out_icode);
1286 #endif
1287
1288       /* We found no existing reload suitable for re-use.
1289          So add an additional reload.  */
1290
1291 #ifdef SECONDARY_MEMORY_NEEDED
1292       /* If a memory location is needed for the copy, make one.  */
1293       if (in != 0 && (GET_CODE (in) == REG || GET_CODE (in) == SUBREG)
1294           && reg_or_subregno (in) < FIRST_PSEUDO_REGISTER
1295           && SECONDARY_MEMORY_NEEDED (REGNO_REG_CLASS (reg_or_subregno (in)),
1296                                       class, inmode))
1297         get_secondary_mem (in, inmode, opnum, type);
1298 #endif
1299
1300       i = n_reloads;
1301       rld[i].in = in;
1302       rld[i].out = out;
1303       rld[i].class = class;
1304       rld[i].inmode = inmode;
1305       rld[i].outmode = outmode;
1306       rld[i].reg_rtx = 0;
1307       rld[i].optional = optional;
1308       rld[i].inc = 0;
1309       rld[i].nocombine = 0;
1310       rld[i].in_reg = inloc ? *inloc : 0;
1311       rld[i].out_reg = outloc ? *outloc : 0;
1312       rld[i].opnum = opnum;
1313       rld[i].when_needed = type;
1314       rld[i].secondary_in_reload = secondary_in_reload;
1315       rld[i].secondary_out_reload = secondary_out_reload;
1316       rld[i].secondary_in_icode = secondary_in_icode;
1317       rld[i].secondary_out_icode = secondary_out_icode;
1318       rld[i].secondary_p = 0;
1319
1320       n_reloads++;
1321
1322 #ifdef SECONDARY_MEMORY_NEEDED
1323       if (out != 0 && (GET_CODE (out) == REG || GET_CODE (out) == SUBREG)
1324           && reg_or_subregno (out) < FIRST_PSEUDO_REGISTER
1325           && SECONDARY_MEMORY_NEEDED (class,
1326                                       REGNO_REG_CLASS (reg_or_subregno (out)),
1327                                       outmode))
1328         get_secondary_mem (out, outmode, opnum, type);
1329 #endif
1330     }
1331   else
1332     {
1333       /* We are reusing an existing reload,
1334          but we may have additional information for it.
1335          For example, we may now have both IN and OUT
1336          while the old one may have just one of them.  */
1337
1338       /* The modes can be different.  If they are, we want to reload in
1339          the larger mode, so that the value is valid for both modes.  */
1340       if (inmode != VOIDmode
1341           && GET_MODE_SIZE (inmode) > GET_MODE_SIZE (rld[i].inmode))
1342         rld[i].inmode = inmode;
1343       if (outmode != VOIDmode
1344           && GET_MODE_SIZE (outmode) > GET_MODE_SIZE (rld[i].outmode))
1345         rld[i].outmode = outmode;
1346       if (in != 0)
1347         {
1348           rtx in_reg = inloc ? *inloc : 0;
1349           /* If we merge reloads for two distinct rtl expressions that
1350              are identical in content, there might be duplicate address
1351              reloads.  Remove the extra set now, so that if we later find
1352              that we can inherit this reload, we can get rid of the
1353              address reloads altogether.
1354
1355              Do not do this if both reloads are optional since the result
1356              would be an optional reload which could potentially leave
1357              unresolved address replacements.
1358
1359              It is not sufficient to call transfer_replacements since
1360              choose_reload_regs will remove the replacements for address
1361              reloads of inherited reloads which results in the same
1362              problem.  */
1363           if (rld[i].in != in && rtx_equal_p (in, rld[i].in)
1364               && ! (rld[i].optional && optional))
1365             {
1366               /* We must keep the address reload with the lower operand
1367                  number alive.  */
1368               if (opnum > rld[i].opnum)
1369                 {
1370                   remove_address_replacements (in);
1371                   in = rld[i].in;
1372                   in_reg = rld[i].in_reg;
1373                 }
1374               else
1375                 remove_address_replacements (rld[i].in);
1376             }
1377           rld[i].in = in;
1378           rld[i].in_reg = in_reg;
1379         }
1380       if (out != 0)
1381         {
1382           rld[i].out = out;
1383           rld[i].out_reg = outloc ? *outloc : 0;
1384         }
1385       if (reg_class_subset_p (class, rld[i].class))
1386         rld[i].class = class;
1387       rld[i].optional &= optional;
1388       if (MERGE_TO_OTHER (type, rld[i].when_needed,
1389                           opnum, rld[i].opnum))
1390         rld[i].when_needed = RELOAD_OTHER;
1391       rld[i].opnum = MIN (rld[i].opnum, opnum);
1392     }
1393
1394   /* If the ostensible rtx being reloaded differs from the rtx found
1395      in the location to substitute, this reload is not safe to combine
1396      because we cannot reliably tell whether it appears in the insn.  */
1397
1398   if (in != 0 && in != *inloc)
1399     rld[i].nocombine = 1;
1400
1401 #if 0
1402   /* This was replaced by changes in find_reloads_address_1 and the new
1403      function inc_for_reload, which go with a new meaning of reload_inc.  */
1404
1405   /* If this is an IN/OUT reload in an insn that sets the CC,
1406      it must be for an autoincrement.  It doesn't work to store
1407      the incremented value after the insn because that would clobber the CC.
1408      So we must do the increment of the value reloaded from,
1409      increment it, store it back, then decrement again.  */
1410   if (out != 0 && sets_cc0_p (PATTERN (this_insn)))
1411     {
1412       out = 0;
1413       rld[i].out = 0;
1414       rld[i].inc = find_inc_amount (PATTERN (this_insn), in);
1415       /* If we did not find a nonzero amount-to-increment-by,
1416          that contradicts the belief that IN is being incremented
1417          in an address in this insn.  */
1418       if (rld[i].inc == 0)
1419         abort ();
1420     }
1421 #endif
1422
1423   /* If we will replace IN and OUT with the reload-reg,
1424      record where they are located so that substitution need
1425      not do a tree walk.  */
1426
1427   if (replace_reloads)
1428     {
1429       if (inloc != 0)
1430         {
1431           struct replacement *r = &replacements[n_replacements++];
1432           r->what = i;
1433           r->subreg_loc = in_subreg_loc;
1434           r->where = inloc;
1435           r->mode = inmode;
1436         }
1437       if (outloc != 0 && outloc != inloc)
1438         {
1439           struct replacement *r = &replacements[n_replacements++];
1440           r->what = i;
1441           r->where = outloc;
1442           r->subreg_loc = out_subreg_loc;
1443           r->mode = outmode;
1444         }
1445     }
1446
1447   /* If this reload is just being introduced and it has both
1448      an incoming quantity and an outgoing quantity that are
1449      supposed to be made to match, see if either one of the two
1450      can serve as the place to reload into.
1451
1452      If one of them is acceptable, set rld[i].reg_rtx
1453      to that one.  */
1454
1455   if (in != 0 && out != 0 && in != out && rld[i].reg_rtx == 0)
1456     {
1457       rld[i].reg_rtx = find_dummy_reload (in, out, inloc, outloc,
1458                                           inmode, outmode,
1459                                           rld[i].class, i,
1460                                           earlyclobber_operand_p (out));
1461
1462       /* If the outgoing register already contains the same value
1463          as the incoming one, we can dispense with loading it.
1464          The easiest way to tell the caller that is to give a phony
1465          value for the incoming operand (same as outgoing one).  */
1466       if (rld[i].reg_rtx == out
1467           && (GET_CODE (in) == REG || CONSTANT_P (in))
1468           && 0 != find_equiv_reg (in, this_insn, 0, REGNO (out),
1469                                   static_reload_reg_p, i, inmode))
1470         rld[i].in = out;
1471     }
1472
1473   /* If this is an input reload and the operand contains a register that
1474      dies in this insn and is used nowhere else, see if it is the right class
1475      to be used for this reload.  Use it if so.  (This occurs most commonly
1476      in the case of paradoxical SUBREGs and in-out reloads).  We cannot do
1477      this if it is also an output reload that mentions the register unless
1478      the output is a SUBREG that clobbers an entire register.
1479
1480      Note that the operand might be one of the spill regs, if it is a
1481      pseudo reg and we are in a block where spilling has not taken place.
1482      But if there is no spilling in this block, that is OK.
1483      An explicitly used hard reg cannot be a spill reg.  */
1484
1485   if (rld[i].reg_rtx == 0 && in != 0)
1486     {
1487       rtx note;
1488       int regno;
1489       enum machine_mode rel_mode = inmode;
1490
1491       if (out && GET_MODE_SIZE (outmode) > GET_MODE_SIZE (inmode))
1492         rel_mode = outmode;
1493
1494       for (note = REG_NOTES (this_insn); note; note = XEXP (note, 1))
1495         if (REG_NOTE_KIND (note) == REG_DEAD
1496             && GET_CODE (XEXP (note, 0)) == REG
1497             && (regno = REGNO (XEXP (note, 0))) < FIRST_PSEUDO_REGISTER
1498             && reg_mentioned_p (XEXP (note, 0), in)
1499             && ! refers_to_regno_for_reload_p (regno,
1500                                                (regno
1501                                                 + HARD_REGNO_NREGS (regno,
1502                                                                     rel_mode)),
1503                                                PATTERN (this_insn), inloc)
1504             /* If this is also an output reload, IN cannot be used as
1505                the reload register if it is set in this insn unless IN
1506                is also OUT.  */
1507             && (out == 0 || in == out
1508                 || ! hard_reg_set_here_p (regno,
1509                                           (regno
1510                                            + HARD_REGNO_NREGS (regno,
1511                                                                rel_mode)),
1512                                           PATTERN (this_insn)))
1513             /* ??? Why is this code so different from the previous?
1514                Is there any simple coherent way to describe the two together?
1515                What's going on here.  */
1516             && (in != out
1517                 || (GET_CODE (in) == SUBREG
1518                     && (((GET_MODE_SIZE (GET_MODE (in)) + (UNITS_PER_WORD - 1))
1519                          / UNITS_PER_WORD)
1520                         == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
1521                              + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD))))
1522             /* Make sure the operand fits in the reg that dies.  */
1523             && (GET_MODE_SIZE (rel_mode)
1524                 <= GET_MODE_SIZE (GET_MODE (XEXP (note, 0))))
1525             && HARD_REGNO_MODE_OK (regno, inmode)
1526             && HARD_REGNO_MODE_OK (regno, outmode))
1527           {
1528             unsigned int offs;
1529             unsigned int nregs = MAX (HARD_REGNO_NREGS (regno, inmode),
1530                                       HARD_REGNO_NREGS (regno, outmode));
1531
1532             for (offs = 0; offs < nregs; offs++)
1533               if (fixed_regs[regno + offs]
1534                   || ! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
1535                                           regno + offs))
1536                 break;
1537
1538             if (offs == nregs)
1539               {
1540                 rld[i].reg_rtx = gen_rtx_REG (rel_mode, regno);
1541                 break;
1542               }
1543           }
1544     }
1545
1546   if (out)
1547     output_reloadnum = i;
1548
1549   return i;
1550 }
1551
1552 /* Record an additional place we must replace a value
1553    for which we have already recorded a reload.
1554    RELOADNUM is the value returned by push_reload
1555    when the reload was recorded.
1556    This is used in insn patterns that use match_dup.  */
1557
1558 static void
1559 push_replacement (loc, reloadnum, mode)
1560      rtx *loc;
1561      int reloadnum;
1562      enum machine_mode mode;
1563 {
1564   if (replace_reloads)
1565     {
1566       struct replacement *r = &replacements[n_replacements++];
1567       r->what = reloadnum;
1568       r->where = loc;
1569       r->subreg_loc = 0;
1570       r->mode = mode;
1571     }
1572 }
1573
1574 /* Duplicate any replacement we have recorded to apply at
1575    location ORIG_LOC to also be performed at DUP_LOC.
1576    This is used in insn patterns that use match_dup.  */
1577
1578 static void
1579 dup_replacements (dup_loc, orig_loc)
1580      rtx *dup_loc;
1581      rtx *orig_loc;
1582 {
1583   int i, n = n_replacements;
1584
1585   for (i = 0; i < n; i++)
1586     {
1587       struct replacement *r = &replacements[i];
1588       if (r->where == orig_loc)
1589         push_replacement (dup_loc, r->what, r->mode);
1590     }
1591 }
1592 \f
1593 /* Transfer all replacements that used to be in reload FROM to be in
1594    reload TO.  */
1595
1596 void
1597 transfer_replacements (to, from)
1598      int to, from;
1599 {
1600   int i;
1601
1602   for (i = 0; i < n_replacements; i++)
1603     if (replacements[i].what == from)
1604       replacements[i].what = to;
1605 }
1606 \f
1607 /* IN_RTX is the value loaded by a reload that we now decided to inherit,
1608    or a subpart of it.  If we have any replacements registered for IN_RTX,
1609    cancel the reloads that were supposed to load them.
1610    Return nonzero if we canceled any reloads.  */
1611 int
1612 remove_address_replacements (in_rtx)
1613      rtx in_rtx;
1614 {
1615   int i, j;
1616   char reload_flags[MAX_RELOADS];
1617   int something_changed = 0;
1618
1619   memset (reload_flags, 0, sizeof reload_flags);
1620   for (i = 0, j = 0; i < n_replacements; i++)
1621     {
1622       if (loc_mentioned_in_p (replacements[i].where, in_rtx))
1623         reload_flags[replacements[i].what] |= 1;
1624       else
1625         {
1626           replacements[j++] = replacements[i];
1627           reload_flags[replacements[i].what] |= 2;
1628         }
1629     }
1630   /* Note that the following store must be done before the recursive calls.  */
1631   n_replacements = j;
1632
1633   for (i = n_reloads - 1; i >= 0; i--)
1634     {
1635       if (reload_flags[i] == 1)
1636         {
1637           deallocate_reload_reg (i);
1638           remove_address_replacements (rld[i].in);
1639           rld[i].in = 0;
1640           something_changed = 1;
1641         }
1642     }
1643   return something_changed;
1644 }
1645 \f
1646 /* If there is only one output reload, and it is not for an earlyclobber
1647    operand, try to combine it with a (logically unrelated) input reload
1648    to reduce the number of reload registers needed.
1649
1650    This is safe if the input reload does not appear in
1651    the value being output-reloaded, because this implies
1652    it is not needed any more once the original insn completes.
1653
1654    If that doesn't work, see we can use any of the registers that
1655    die in this insn as a reload register.  We can if it is of the right
1656    class and does not appear in the value being output-reloaded.  */
1657
1658 static void
1659 combine_reloads ()
1660 {
1661   int i;
1662   int output_reload = -1;
1663   int secondary_out = -1;
1664   rtx note;
1665
1666   /* Find the output reload; return unless there is exactly one
1667      and that one is mandatory.  */
1668
1669   for (i = 0; i < n_reloads; i++)
1670     if (rld[i].out != 0)
1671       {
1672         if (output_reload >= 0)
1673           return;
1674         output_reload = i;
1675       }
1676
1677   if (output_reload < 0 || rld[output_reload].optional)
1678     return;
1679
1680   /* An input-output reload isn't combinable.  */
1681
1682   if (rld[output_reload].in != 0)
1683     return;
1684
1685   /* If this reload is for an earlyclobber operand, we can't do anything.  */
1686   if (earlyclobber_operand_p (rld[output_reload].out))
1687     return;
1688
1689   /* If there is a reload for part of the address of this operand, we would
1690      need to chnage it to RELOAD_FOR_OTHER_ADDRESS.  But that would extend
1691      its life to the point where doing this combine would not lower the
1692      number of spill registers needed.  */
1693   for (i = 0; i < n_reloads; i++)
1694     if ((rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS
1695          || rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
1696         && rld[i].opnum == rld[output_reload].opnum)
1697       return;
1698
1699   /* Check each input reload; can we combine it?  */
1700
1701   for (i = 0; i < n_reloads; i++)
1702     if (rld[i].in && ! rld[i].optional && ! rld[i].nocombine
1703         /* Life span of this reload must not extend past main insn.  */
1704         && rld[i].when_needed != RELOAD_FOR_OUTPUT_ADDRESS
1705         && rld[i].when_needed != RELOAD_FOR_OUTADDR_ADDRESS
1706         && rld[i].when_needed != RELOAD_OTHER
1707         && (CLASS_MAX_NREGS (rld[i].class, rld[i].inmode)
1708             == CLASS_MAX_NREGS (rld[output_reload].class,
1709                                 rld[output_reload].outmode))
1710         && rld[i].inc == 0
1711         && rld[i].reg_rtx == 0
1712 #ifdef SECONDARY_MEMORY_NEEDED
1713         /* Don't combine two reloads with different secondary
1714            memory locations.  */
1715         && (secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[i].opnum] == 0
1716             || secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[output_reload].opnum] == 0
1717             || rtx_equal_p (secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[i].opnum],
1718                             secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[output_reload].opnum]))
1719 #endif
1720         && (SMALL_REGISTER_CLASSES
1721             ? (rld[i].class == rld[output_reload].class)
1722             : (reg_class_subset_p (rld[i].class,
1723                                    rld[output_reload].class)
1724                || reg_class_subset_p (rld[output_reload].class,
1725                                       rld[i].class)))
1726         && (MATCHES (rld[i].in, rld[output_reload].out)
1727             /* Args reversed because the first arg seems to be
1728                the one that we imagine being modified
1729                while the second is the one that might be affected.  */
1730             || (! reg_overlap_mentioned_for_reload_p (rld[output_reload].out,
1731                                                       rld[i].in)
1732                 /* However, if the input is a register that appears inside
1733                    the output, then we also can't share.
1734                    Imagine (set (mem (reg 69)) (plus (reg 69) ...)).
1735                    If the same reload reg is used for both reg 69 and the
1736                    result to be stored in memory, then that result
1737                    will clobber the address of the memory ref.  */
1738                 && ! (GET_CODE (rld[i].in) == REG
1739                       && reg_overlap_mentioned_for_reload_p (rld[i].in,
1740                                                              rld[output_reload].out))))
1741         && ! reload_inner_reg_of_subreg (rld[i].in, rld[i].inmode,
1742                                          rld[i].when_needed != RELOAD_FOR_INPUT)
1743         && (reg_class_size[(int) rld[i].class]
1744             || SMALL_REGISTER_CLASSES)
1745         /* We will allow making things slightly worse by combining an
1746            input and an output, but no worse than that.  */
1747         && (rld[i].when_needed == RELOAD_FOR_INPUT
1748             || rld[i].when_needed == RELOAD_FOR_OUTPUT))
1749       {
1750         int j;
1751
1752         /* We have found a reload to combine with!  */
1753         rld[i].out = rld[output_reload].out;
1754         rld[i].out_reg = rld[output_reload].out_reg;
1755         rld[i].outmode = rld[output_reload].outmode;
1756         /* Mark the old output reload as inoperative.  */
1757         rld[output_reload].out = 0;
1758         /* The combined reload is needed for the entire insn.  */
1759         rld[i].when_needed = RELOAD_OTHER;
1760         /* If the output reload had a secondary reload, copy it.  */
1761         if (rld[output_reload].secondary_out_reload != -1)
1762           {
1763             rld[i].secondary_out_reload
1764               = rld[output_reload].secondary_out_reload;
1765             rld[i].secondary_out_icode
1766               = rld[output_reload].secondary_out_icode;
1767           }
1768
1769 #ifdef SECONDARY_MEMORY_NEEDED
1770         /* Copy any secondary MEM.  */
1771         if (secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[output_reload].opnum] != 0)
1772           secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[i].opnum]
1773             = secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[output_reload].opnum];
1774 #endif
1775         /* If required, minimize the register class.  */
1776         if (reg_class_subset_p (rld[output_reload].class,
1777                                 rld[i].class))
1778           rld[i].class = rld[output_reload].class;
1779
1780         /* Transfer all replacements from the old reload to the combined.  */
1781         for (j = 0; j < n_replacements; j++)
1782           if (replacements[j].what == output_reload)
1783             replacements[j].what = i;
1784
1785         return;
1786       }
1787
1788   /* If this insn has only one operand that is modified or written (assumed
1789      to be the first),  it must be the one corresponding to this reload.  It
1790      is safe to use anything that dies in this insn for that output provided
1791      that it does not occur in the output (we already know it isn't an
1792      earlyclobber.  If this is an asm insn, give up.  */
1793
1794   if (INSN_CODE (this_insn) == -1)
1795     return;
1796
1797   for (i = 1; i < insn_data[INSN_CODE (this_insn)].n_operands; i++)
1798     if (insn_data[INSN_CODE (this_insn)].operand[i].constraint[0] == '='
1799         || insn_data[INSN_CODE (this_insn)].operand[i].constraint[0] == '+')
1800       return;
1801
1802   /* See if some hard register that dies in this insn and is not used in
1803      the output is the right class.  Only works if the register we pick
1804      up can fully hold our output reload.  */
1805   for (note = REG_NOTES (this_insn); note; note = XEXP (note, 1))
1806     if (REG_NOTE_KIND (note) == REG_DEAD
1807         && GET_CODE (XEXP (note, 0)) == REG
1808         && ! reg_overlap_mentioned_for_reload_p (XEXP (note, 0),
1809                                                  rld[output_reload].out)
1810         && REGNO (XEXP (note, 0)) < FIRST_PSEUDO_REGISTER
1811         && HARD_REGNO_MODE_OK (REGNO (XEXP (note, 0)), rld[output_reload].outmode)
1812         && TEST_HARD_REG_BIT (reg_class_contents[(int) rld[output_reload].class],
1813                               REGNO (XEXP (note, 0)))
1814         && (HARD_REGNO_NREGS (REGNO (XEXP (note, 0)), rld[output_reload].outmode)
1815             <= HARD_REGNO_NREGS (REGNO (XEXP (note, 0)), GET_MODE (XEXP (note, 0))))
1816         /* Ensure that a secondary or tertiary reload for this output
1817            won't want this register.  */
1818         && ((secondary_out = rld[output_reload].secondary_out_reload) == -1
1819             || (! (TEST_HARD_REG_BIT
1820                    (reg_class_contents[(int) rld[secondary_out].class],
1821                     REGNO (XEXP (note, 0))))
1822                 && ((secondary_out = rld[secondary_out].secondary_out_reload) == -1
1823                     ||  ! (TEST_HARD_REG_BIT
1824                            (reg_class_contents[(int) rld[secondary_out].class],
1825                             REGNO (XEXP (note, 0)))))))
1826         && ! fixed_regs[REGNO (XEXP (note, 0))])
1827       {
1828         rld[output_reload].reg_rtx
1829           = gen_rtx_REG (rld[output_reload].outmode,
1830                          REGNO (XEXP (note, 0)));
1831         return;
1832       }
1833 }
1834 \f
1835 /* Try to find a reload register for an in-out reload (expressions IN and OUT).
1836    See if one of IN and OUT is a register that may be used;
1837    this is desirable since a spill-register won't be needed.
1838    If so, return the register rtx that proves acceptable.
1839
1840    INLOC and OUTLOC are locations where IN and OUT appear in the insn.
1841    CLASS is the register class required for the reload.
1842
1843    If FOR_REAL is >= 0, it is the number of the reload,
1844    and in some cases when it can be discovered that OUT doesn't need
1845    to be computed, clear out rld[FOR_REAL].out.
1846
1847    If FOR_REAL is -1, this should not be done, because this call
1848    is just to see if a register can be found, not to find and install it.
1849
1850    EARLYCLOBBER is nonzero if OUT is an earlyclobber operand.  This
1851    puts an additional constraint on being able to use IN for OUT since
1852    IN must not appear elsewhere in the insn (it is assumed that IN itself
1853    is safe from the earlyclobber).  */
1854
1855 static rtx
1856 find_dummy_reload (real_in, real_out, inloc, outloc,
1857                    inmode, outmode, class, for_real, earlyclobber)
1858      rtx real_in, real_out;
1859      rtx *inloc, *outloc;
1860      enum machine_mode inmode, outmode;
1861      enum reg_class class;
1862      int for_real;
1863      int earlyclobber;
1864 {
1865   rtx in = real_in;
1866   rtx out = real_out;
1867   int in_offset = 0;
1868   int out_offset = 0;
1869   rtx value = 0;
1870
1871   /* If operands exceed a word, we can't use either of them
1872      unless they have the same size.  */
1873   if (GET_MODE_SIZE (outmode) != GET_MODE_SIZE (inmode)
1874       && (GET_MODE_SIZE (outmode) > UNITS_PER_WORD
1875           || GET_MODE_SIZE (inmode) > UNITS_PER_WORD))
1876     return 0;
1877
1878   /* Note that {in,out}_offset are needed only when 'in' or 'out'
1879      respectively refers to a hard register.  */
1880
1881   /* Find the inside of any subregs.  */
1882   while (GET_CODE (out) == SUBREG)
1883     {
1884       if (GET_CODE (SUBREG_REG (out)) == REG
1885           && REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER)
1886         out_offset += subreg_regno_offset (REGNO (SUBREG_REG (out)),
1887                                            GET_MODE (SUBREG_REG (out)),
1888                                            SUBREG_BYTE (out),
1889                                            GET_MODE (out));
1890       out = SUBREG_REG (out);
1891     }
1892   while (GET_CODE (in) == SUBREG)
1893     {
1894       if (GET_CODE (SUBREG_REG (in)) == REG
1895           && REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER)
1896         in_offset += subreg_regno_offset (REGNO (SUBREG_REG (in)),
1897                                           GET_MODE (SUBREG_REG (in)),
1898                                           SUBREG_BYTE (in),
1899                                           GET_MODE (in));
1900       in = SUBREG_REG (in);
1901     }
1902
1903   /* Narrow down the reg class, the same way push_reload will;
1904      otherwise we might find a dummy now, but push_reload won't.  */
1905   class = PREFERRED_RELOAD_CLASS (in, class);
1906
1907   /* See if OUT will do.  */
1908   if (GET_CODE (out) == REG
1909       && REGNO (out) < FIRST_PSEUDO_REGISTER)
1910     {
1911       unsigned int regno = REGNO (out) + out_offset;
1912       unsigned int nwords = HARD_REGNO_NREGS (regno, outmode);
1913       rtx saved_rtx;
1914
1915       /* When we consider whether the insn uses OUT,
1916          ignore references within IN.  They don't prevent us
1917          from copying IN into OUT, because those refs would
1918          move into the insn that reloads IN.
1919
1920          However, we only ignore IN in its role as this reload.
1921          If the insn uses IN elsewhere and it contains OUT,
1922          that counts.  We can't be sure it's the "same" operand
1923          so it might not go through this reload.  */
1924       saved_rtx = *inloc;
1925       *inloc = const0_rtx;
1926
1927       if (regno < FIRST_PSEUDO_REGISTER
1928           && HARD_REGNO_MODE_OK (regno, outmode)
1929           && ! refers_to_regno_for_reload_p (regno, regno + nwords,
1930                                              PATTERN (this_insn), outloc))
1931         {
1932           unsigned int i;
1933
1934           for (i = 0; i < nwords; i++)
1935             if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
1936                                      regno + i))
1937               break;
1938
1939           if (i == nwords)
1940             {
1941               if (GET_CODE (real_out) == REG)
1942                 value = real_out;
1943               else
1944                 value = gen_rtx_REG (outmode, regno);
1945             }
1946         }
1947
1948       *inloc = saved_rtx;
1949     }
1950
1951   /* Consider using IN if OUT was not acceptable
1952      or if OUT dies in this insn (like the quotient in a divmod insn).
1953      We can't use IN unless it is dies in this insn,
1954      which means we must know accurately which hard regs are live.
1955      Also, the result can't go in IN if IN is used within OUT,
1956      or if OUT is an earlyclobber and IN appears elsewhere in the insn.  */
1957   if (hard_regs_live_known
1958       && GET_CODE (in) == REG
1959       && REGNO (in) < FIRST_PSEUDO_REGISTER
1960       && (value == 0
1961           || find_reg_note (this_insn, REG_UNUSED, real_out))
1962       && find_reg_note (this_insn, REG_DEAD, real_in)
1963       && !fixed_regs[REGNO (in)]
1964       && HARD_REGNO_MODE_OK (REGNO (in),
1965                              /* The only case where out and real_out might
1966                                 have different modes is where real_out
1967                                 is a subreg, and in that case, out
1968                                 has a real mode.  */
1969                              (GET_MODE (out) != VOIDmode
1970                               ? GET_MODE (out) : outmode)))
1971     {
1972       unsigned int regno = REGNO (in) + in_offset;
1973       unsigned int nwords = HARD_REGNO_NREGS (regno, inmode);
1974
1975       if (! refers_to_regno_for_reload_p (regno, regno + nwords, out, (rtx*) 0)
1976           && ! hard_reg_set_here_p (regno, regno + nwords,
1977                                     PATTERN (this_insn))
1978           && (! earlyclobber
1979               || ! refers_to_regno_for_reload_p (regno, regno + nwords,
1980                                                  PATTERN (this_insn), inloc)))
1981         {
1982           unsigned int i;
1983
1984           for (i = 0; i < nwords; i++)
1985             if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
1986                                      regno + i))
1987               break;
1988
1989           if (i == nwords)
1990             {
1991               /* If we were going to use OUT as the reload reg
1992                  and changed our mind, it means OUT is a dummy that
1993                  dies here.  So don't bother copying value to it.  */
1994               if (for_real >= 0 && value == real_out)
1995                 rld[for_real].out = 0;
1996               if (GET_CODE (real_in) == REG)
1997                 value = real_in;
1998               else
1999                 value = gen_rtx_REG (inmode, regno);
2000             }
2001         }
2002     }
2003
2004   return value;
2005 }
2006 \f
2007 /* This page contains subroutines used mainly for determining
2008    whether the IN or an OUT of a reload can serve as the
2009    reload register.  */
2010
2011 /* Return 1 if X is an operand of an insn that is being earlyclobbered.  */
2012
2013 int
2014 earlyclobber_operand_p (x)
2015      rtx x;
2016 {
2017   int i;
2018
2019   for (i = 0; i < n_earlyclobbers; i++)
2020     if (reload_earlyclobbers[i] == x)
2021       return 1;
2022
2023   return 0;
2024 }
2025
2026 /* Return 1 if expression X alters a hard reg in the range
2027    from BEG_REGNO (inclusive) to END_REGNO (exclusive),
2028    either explicitly or in the guise of a pseudo-reg allocated to REGNO.
2029    X should be the body of an instruction.  */
2030
2031 static int
2032 hard_reg_set_here_p (beg_regno, end_regno, x)
2033      unsigned int beg_regno, end_regno;
2034      rtx x;
2035 {
2036   if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
2037     {
2038       rtx op0 = SET_DEST (x);
2039
2040       while (GET_CODE (op0) == SUBREG)
2041         op0 = SUBREG_REG (op0);
2042       if (GET_CODE (op0) == REG)
2043         {
2044           unsigned int r = REGNO (op0);
2045
2046           /* See if this reg overlaps range under consideration.  */
2047           if (r < end_regno
2048               && r + HARD_REGNO_NREGS (r, GET_MODE (op0)) > beg_regno)
2049             return 1;
2050         }
2051     }
2052   else if (GET_CODE (x) == PARALLEL)
2053     {
2054       int i = XVECLEN (x, 0) - 1;
2055
2056       for (; i >= 0; i--)
2057         if (hard_reg_set_here_p (beg_regno, end_regno, XVECEXP (x, 0, i)))
2058           return 1;
2059     }
2060
2061   return 0;
2062 }
2063
2064 /* Return 1 if ADDR is a valid memory address for mode MODE,
2065    and check that each pseudo reg has the proper kind of
2066    hard reg.  */
2067
2068 int
2069 strict_memory_address_p (mode, addr)
2070      enum machine_mode mode ATTRIBUTE_UNUSED;
2071      rtx addr;
2072 {
2073   GO_IF_LEGITIMATE_ADDRESS (mode, addr, win);
2074   return 0;
2075
2076  win:
2077   return 1;
2078 }
2079 \f
2080 /* Like rtx_equal_p except that it allows a REG and a SUBREG to match
2081    if they are the same hard reg, and has special hacks for
2082    autoincrement and autodecrement.
2083    This is specifically intended for find_reloads to use
2084    in determining whether two operands match.
2085    X is the operand whose number is the lower of the two.
2086
2087    The value is 2 if Y contains a pre-increment that matches
2088    a non-incrementing address in X.  */
2089
2090 /* ??? To be completely correct, we should arrange to pass
2091    for X the output operand and for Y the input operand.
2092    For now, we assume that the output operand has the lower number
2093    because that is natural in (SET output (... input ...)).  */
2094
2095 int
2096 operands_match_p (x, y)
2097      rtx x, y;
2098 {
2099   int i;
2100   RTX_CODE code = GET_CODE (x);
2101   const char *fmt;
2102   int success_2;
2103
2104   if (x == y)
2105     return 1;
2106   if ((code == REG || (code == SUBREG && GET_CODE (SUBREG_REG (x)) == REG))
2107       && (GET_CODE (y) == REG || (GET_CODE (y) == SUBREG
2108                                   && GET_CODE (SUBREG_REG (y)) == REG)))
2109     {
2110       int j;
2111
2112       if (code == SUBREG)
2113         {
2114           i = REGNO (SUBREG_REG (x));
2115           if (i >= FIRST_PSEUDO_REGISTER)
2116             goto slow;
2117           i += subreg_regno_offset (REGNO (SUBREG_REG (x)),
2118                                     GET_MODE (SUBREG_REG (x)),
2119                                     SUBREG_BYTE (x),
2120                                     GET_MODE (x));
2121         }
2122       else
2123         i = REGNO (x);
2124
2125       if (GET_CODE (y) == SUBREG)
2126         {
2127           j = REGNO (SUBREG_REG (y));
2128           if (j >= FIRST_PSEUDO_REGISTER)
2129             goto slow;
2130           j += subreg_regno_offset (REGNO (SUBREG_REG (y)),
2131                                     GET_MODE (SUBREG_REG (y)),
2132                                     SUBREG_BYTE (y),
2133                                     GET_MODE (y));
2134         }
2135       else
2136         j = REGNO (y);
2137
2138       /* On a WORDS_BIG_ENDIAN machine, point to the last register of a
2139          multiple hard register group, so that for example (reg:DI 0) and
2140          (reg:SI 1) will be considered the same register.  */
2141       if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD
2142           && i < FIRST_PSEUDO_REGISTER)
2143         i += (GET_MODE_SIZE (GET_MODE (x)) / UNITS_PER_WORD) - 1;
2144       if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (y)) > UNITS_PER_WORD
2145           && j < FIRST_PSEUDO_REGISTER)
2146         j += (GET_MODE_SIZE (GET_MODE (y)) / UNITS_PER_WORD) - 1;
2147
2148       return i == j;
2149     }
2150   /* If two operands must match, because they are really a single
2151      operand of an assembler insn, then two postincrements are invalid
2152      because the assembler insn would increment only once.
2153      On the other hand, a postincrement matches ordinary indexing
2154      if the postincrement is the output operand.  */
2155   if (code == POST_DEC || code == POST_INC || code == POST_MODIFY)
2156     return operands_match_p (XEXP (x, 0), y);
2157   /* Two preincrements are invalid
2158      because the assembler insn would increment only once.
2159      On the other hand, a preincrement matches ordinary indexing
2160      if the preincrement is the input operand.
2161      In this case, return 2, since some callers need to do special
2162      things when this happens.  */
2163   if (GET_CODE (y) == PRE_DEC || GET_CODE (y) == PRE_INC
2164       || GET_CODE (y) == PRE_MODIFY)
2165     return operands_match_p (x, XEXP (y, 0)) ? 2 : 0;
2166
2167  slow:
2168
2169   /* Now we have disposed of all the cases
2170      in which different rtx codes can match.  */
2171   if (code != GET_CODE (y))
2172     return 0;
2173   if (code == LABEL_REF)
2174     return XEXP (x, 0) == XEXP (y, 0);
2175   if (code == SYMBOL_REF)
2176     return XSTR (x, 0) == XSTR (y, 0);
2177
2178   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.  */
2179
2180   if (GET_MODE (x) != GET_MODE (y))
2181     return 0;
2182
2183   /* Compare the elements.  If any pair of corresponding elements
2184      fail to match, return 0 for the whole things.  */
2185
2186   success_2 = 0;
2187   fmt = GET_RTX_FORMAT (code);
2188   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2189     {
2190       int val, j;
2191       switch (fmt[i])
2192         {
2193         case 'w':
2194           if (XWINT (x, i) != XWINT (y, i))
2195             return 0;
2196           break;
2197
2198         case 'i':
2199           if (XINT (x, i) != XINT (y, i))
2200             return 0;
2201           break;
2202
2203         case 'e':
2204           val = operands_match_p (XEXP (x, i), XEXP (y, i));
2205           if (val == 0)
2206             return 0;
2207           /* If any subexpression returns 2,
2208              we should return 2 if we are successful.  */
2209           if (val == 2)
2210             success_2 = 1;
2211           break;
2212
2213         case '0':
2214           break;
2215
2216         case 'E':
2217           if (XVECLEN (x, i) != XVECLEN (y, i))
2218             return 0;
2219           for (j = XVECLEN (x, i) - 1; j >= 0; --j)
2220             {
2221               val = operands_match_p (XVECEXP (x, i, j), XVECEXP (y, i, j));
2222               if (val == 0)
2223                 return 0;
2224               if (val == 2)
2225                 success_2 = 1;
2226             }
2227           break;
2228
2229           /* It is believed that rtx's at this level will never
2230              contain anything but integers and other rtx's,
2231              except for within LABEL_REFs and SYMBOL_REFs.  */
2232         default:
2233           abort ();
2234         }
2235     }
2236   return 1 + success_2;
2237 }
2238 \f
2239 /* Describe the range of registers or memory referenced by X.
2240    If X is a register, set REG_FLAG and put the first register
2241    number into START and the last plus one into END.
2242    If X is a memory reference, put a base address into BASE
2243    and a range of integer offsets into START and END.
2244    If X is pushing on the stack, we can assume it causes no trouble,
2245    so we set the SAFE field.  */
2246
2247 static struct decomposition
2248 decompose (x)
2249      rtx x;
2250 {
2251   struct decomposition val;
2252   int all_const = 0;
2253
2254   val.reg_flag = 0;
2255   val.safe = 0;
2256   val.base = 0;
2257   if (GET_CODE (x) == MEM)
2258     {
2259       rtx base = NULL_RTX, offset = 0;
2260       rtx addr = XEXP (x, 0);
2261
2262       if (GET_CODE (addr) == PRE_DEC || GET_CODE (addr) == PRE_INC
2263           || GET_CODE (addr) == POST_DEC || GET_CODE (addr) == POST_INC)
2264         {
2265           val.base = XEXP (addr, 0);
2266           val.start = -GET_MODE_SIZE (GET_MODE (x));
2267           val.end = GET_MODE_SIZE (GET_MODE (x));
2268           val.safe = REGNO (val.base) == STACK_POINTER_REGNUM;
2269           return val;
2270         }
2271
2272       if (GET_CODE (addr) == PRE_MODIFY || GET_CODE (addr) == POST_MODIFY)
2273         {
2274           if (GET_CODE (XEXP (addr, 1)) == PLUS
2275               && XEXP (addr, 0) == XEXP (XEXP (addr, 1), 0)
2276               && CONSTANT_P (XEXP (XEXP (addr, 1), 1)))
2277             {
2278               val.base  = XEXP (addr, 0);
2279               val.start = -INTVAL (XEXP (XEXP (addr, 1), 1));
2280               val.end   = INTVAL (XEXP (XEXP (addr, 1), 1));
2281               val.safe  = REGNO (val.base) == STACK_POINTER_REGNUM;
2282               return val;
2283             }
2284         }
2285
2286       if (GET_CODE (addr) == CONST)
2287         {
2288           addr = XEXP (addr, 0);
2289           all_const = 1;
2290         }
2291       if (GET_CODE (addr) == PLUS)
2292         {
2293           if (CONSTANT_P (XEXP (addr, 0)))
2294             {
2295               base = XEXP (addr, 1);
2296               offset = XEXP (addr, 0);
2297             }
2298           else if (CONSTANT_P (XEXP (addr, 1)))
2299             {
2300               base = XEXP (addr, 0);
2301               offset = XEXP (addr, 1);
2302             }
2303         }
2304
2305       if (offset == 0)
2306         {
2307           base = addr;
2308           offset = const0_rtx;
2309         }
2310       if (GET_CODE (offset) == CONST)
2311         offset = XEXP (offset, 0);
2312       if (GET_CODE (offset) == PLUS)
2313         {
2314           if (GET_CODE (XEXP (offset, 0)) == CONST_INT)
2315             {
2316               base = gen_rtx_PLUS (GET_MODE (base), base, XEXP (offset, 1));
2317               offset = XEXP (offset, 0);
2318             }
2319           else if (GET_CODE (XEXP (offset, 1)) == CONST_INT)
2320             {
2321               base = gen_rtx_PLUS (GET_MODE (base), base, XEXP (offset, 0));
2322               offset = XEXP (offset, 1);
2323             }
2324           else
2325             {
2326               base = gen_rtx_PLUS (GET_MODE (base), base, offset);
2327               offset = const0_rtx;
2328             }
2329         }
2330       else if (GET_CODE (offset) != CONST_INT)
2331         {
2332           base = gen_rtx_PLUS (GET_MODE (base), base, offset);
2333           offset = const0_rtx;
2334         }
2335
2336       if (all_const && GET_CODE (base) == PLUS)
2337         base = gen_rtx_CONST (GET_MODE (base), base);
2338
2339       if (GET_CODE (offset) != CONST_INT)
2340         abort ();
2341
2342       val.start = INTVAL (offset);
2343       val.end = val.start + GET_MODE_SIZE (GET_MODE (x));
2344       val.base = base;
2345       return val;
2346     }
2347   else if (GET_CODE (x) == REG)
2348     {
2349       val.reg_flag = 1;
2350       val.start = true_regnum (x);
2351       if (val.start < 0)
2352         {
2353           /* A pseudo with no hard reg.  */
2354           val.start = REGNO (x);
2355           val.end = val.start + 1;
2356         }
2357       else
2358         /* A hard reg.  */
2359         val.end = val.start + HARD_REGNO_NREGS (val.start, GET_MODE (x));
2360     }
2361   else if (GET_CODE (x) == SUBREG)
2362     {
2363       if (GET_CODE (SUBREG_REG (x)) != REG)
2364         /* This could be more precise, but it's good enough.  */
2365         return decompose (SUBREG_REG (x));
2366       val.reg_flag = 1;
2367       val.start = true_regnum (x);
2368       if (val.start < 0)
2369         return decompose (SUBREG_REG (x));
2370       else
2371         /* A hard reg.  */
2372         val.end = val.start + HARD_REGNO_NREGS (val.start, GET_MODE (x));
2373     }
2374   else if (CONSTANT_P (x)
2375            /* This hasn't been assigned yet, so it can't conflict yet.  */
2376            || GET_CODE (x) == SCRATCH)
2377     val.safe = 1;
2378   else
2379     abort ();
2380   return val;
2381 }
2382
2383 /* Return 1 if altering Y will not modify the value of X.
2384    Y is also described by YDATA, which should be decompose (Y).  */
2385
2386 static int
2387 immune_p (x, y, ydata)
2388      rtx x, y;
2389      struct decomposition ydata;
2390 {
2391   struct decomposition xdata;
2392
2393   if (ydata.reg_flag)
2394     return !refers_to_regno_for_reload_p (ydata.start, ydata.end, x, (rtx*) 0);
2395   if (ydata.safe)
2396     return 1;
2397
2398   if (GET_CODE (y) != MEM)
2399     abort ();
2400   /* If Y is memory and X is not, Y can't affect X.  */
2401   if (GET_CODE (x) != MEM)
2402     return 1;
2403
2404   xdata = decompose (x);
2405
2406   if (! rtx_equal_p (xdata.base, ydata.base))
2407     {
2408       /* If bases are distinct symbolic constants, there is no overlap.  */
2409       if (CONSTANT_P (xdata.base) && CONSTANT_P (ydata.base))
2410         return 1;
2411       /* Constants and stack slots never overlap.  */
2412       if (CONSTANT_P (xdata.base)
2413           && (ydata.base == frame_pointer_rtx
2414               || ydata.base == hard_frame_pointer_rtx
2415               || ydata.base == stack_pointer_rtx))
2416         return 1;
2417       if (CONSTANT_P (ydata.base)
2418           && (xdata.base == frame_pointer_rtx
2419               || xdata.base == hard_frame_pointer_rtx
2420               || xdata.base == stack_pointer_rtx))
2421         return 1;
2422       /* If either base is variable, we don't know anything.  */
2423       return 0;
2424     }
2425
2426   return (xdata.start >= ydata.end || ydata.start >= xdata.end);
2427 }
2428
2429 /* Similar, but calls decompose.  */
2430
2431 int
2432 safe_from_earlyclobber (op, clobber)
2433      rtx op, clobber;
2434 {
2435   struct decomposition early_data;
2436
2437   early_data = decompose (clobber);
2438   return immune_p (op, clobber, early_data);
2439 }
2440 \f
2441 /* Main entry point of this file: search the body of INSN
2442    for values that need reloading and record them with push_reload.
2443    REPLACE nonzero means record also where the values occur
2444    so that subst_reloads can be used.
2445
2446    IND_LEVELS says how many levels of indirection are supported by this
2447    machine; a value of zero means that a memory reference is not a valid
2448    memory address.
2449
2450    LIVE_KNOWN says we have valid information about which hard
2451    regs are live at each point in the program; this is true when
2452    we are called from global_alloc but false when stupid register
2453    allocation has been done.
2454
2455    RELOAD_REG_P if nonzero is a vector indexed by hard reg number
2456    which is nonnegative if the reg has been commandeered for reloading into.
2457    It is copied into STATIC_RELOAD_REG_P and referenced from there
2458    by various subroutines.
2459
2460    Return TRUE if some operands need to be changed, because of swapping
2461    commutative operands, reg_equiv_address substitution, or whatever.  */
2462
2463 int
2464 find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
2465      rtx insn;
2466      int replace, ind_levels;
2467      int live_known;
2468      short *reload_reg_p;
2469 {
2470   int insn_code_number;
2471   int i, j;
2472   int noperands;
2473   /* These start out as the constraints for the insn
2474      and they are chewed up as we consider alternatives.  */
2475   char *constraints[MAX_RECOG_OPERANDS];
2476   /* These are the preferred classes for an operand, or NO_REGS if it isn't
2477      a register.  */
2478   enum reg_class preferred_class[MAX_RECOG_OPERANDS];
2479   char pref_or_nothing[MAX_RECOG_OPERANDS];
2480   /* Nonzero for a MEM operand whose entire address needs a reload.  */
2481   int address_reloaded[MAX_RECOG_OPERANDS];
2482   /* Value of enum reload_type to use for operand.  */
2483   enum reload_type operand_type[MAX_RECOG_OPERANDS];
2484   /* Value of enum reload_type to use within address of operand.  */
2485   enum reload_type address_type[MAX_RECOG_OPERANDS];
2486   /* Save the usage of each operand.  */
2487   enum reload_usage { RELOAD_READ, RELOAD_READ_WRITE, RELOAD_WRITE } modified[MAX_RECOG_OPERANDS];
2488   int no_input_reloads = 0, no_output_reloads = 0;
2489   int n_alternatives;
2490   int this_alternative[MAX_RECOG_OPERANDS];
2491   char this_alternative_match_win[MAX_RECOG_OPERANDS];
2492   char this_alternative_win[MAX_RECOG_OPERANDS];
2493   char this_alternative_offmemok[MAX_RECOG_OPERANDS];
2494   char this_alternative_earlyclobber[MAX_RECOG_OPERANDS];
2495   int this_alternative_matches[MAX_RECOG_OPERANDS];
2496   int swapped;
2497   int goal_alternative[MAX_RECOG_OPERANDS];
2498   int this_alternative_number;
2499   int goal_alternative_number = 0;
2500   int operand_reloadnum[MAX_RECOG_OPERANDS];
2501   int goal_alternative_matches[MAX_RECOG_OPERANDS];
2502   int goal_alternative_matched[MAX_RECOG_OPERANDS];
2503   char goal_alternative_match_win[MAX_RECOG_OPERANDS];
2504   char goal_alternative_win[MAX_RECOG_OPERANDS];
2505   char goal_alternative_offmemok[MAX_RECOG_OPERANDS];
2506   char goal_alternative_earlyclobber[MAX_RECOG_OPERANDS];
2507   int goal_alternative_swapped;
2508   int best;
2509   int commutative;
2510   char operands_match[MAX_RECOG_OPERANDS][MAX_RECOG_OPERANDS];
2511   rtx substed_operand[MAX_RECOG_OPERANDS];
2512   rtx body = PATTERN (insn);
2513   rtx set = single_set (insn);
2514   int goal_earlyclobber = 0, this_earlyclobber;
2515   enum machine_mode operand_mode[MAX_RECOG_OPERANDS];
2516   int retval = 0;
2517
2518   this_insn = insn;
2519   n_reloads = 0;
2520   n_replacements = 0;
2521   n_earlyclobbers = 0;
2522   replace_reloads = replace;
2523   hard_regs_live_known = live_known;
2524   static_reload_reg_p = reload_reg_p;
2525
2526   /* JUMP_INSNs and CALL_INSNs are not allowed to have any output reloads;
2527      neither are insns that SET cc0.  Insns that use CC0 are not allowed
2528      to have any input reloads.  */
2529   if (GET_CODE (insn) == JUMP_INSN || GET_CODE (insn) == CALL_INSN)
2530     no_output_reloads = 1;
2531
2532 #ifdef HAVE_cc0
2533   if (reg_referenced_p (cc0_rtx, PATTERN (insn)))
2534     no_input_reloads = 1;
2535   if (reg_set_p (cc0_rtx, PATTERN (insn)))
2536     no_output_reloads = 1;
2537 #endif
2538
2539 #ifdef SECONDARY_MEMORY_NEEDED
2540   /* The eliminated forms of any secondary memory locations are per-insn, so
2541      clear them out here.  */
2542
2543   memset ((char *) secondary_memlocs_elim, 0, sizeof secondary_memlocs_elim);
2544 #endif
2545
2546   /* Dispose quickly of (set (reg..) (reg..)) if both have hard regs and it
2547      is cheap to move between them.  If it is not, there may not be an insn
2548      to do the copy, so we may need a reload.  */
2549   if (GET_CODE (body) == SET
2550       && GET_CODE (SET_DEST (body)) == REG
2551       && REGNO (SET_DEST (body)) < FIRST_PSEUDO_REGISTER
2552       && GET_CODE (SET_SRC (body)) == REG
2553       && REGNO (SET_SRC (body)) < FIRST_PSEUDO_REGISTER
2554       && REGISTER_MOVE_COST (GET_MODE (SET_SRC (body)),
2555                              REGNO_REG_CLASS (REGNO (SET_SRC (body))),
2556                              REGNO_REG_CLASS (REGNO (SET_DEST (body)))) == 2)
2557     return 0;
2558
2559   extract_insn (insn);
2560
2561   noperands = reload_n_operands = recog_data.n_operands;
2562   n_alternatives = recog_data.n_alternatives;
2563
2564   /* Just return "no reloads" if insn has no operands with constraints.  */
2565   if (noperands == 0 || n_alternatives == 0)
2566     return 0;
2567
2568   insn_code_number = INSN_CODE (insn);
2569   this_insn_is_asm = insn_code_number < 0;
2570
2571   memcpy (operand_mode, recog_data.operand_mode,
2572           noperands * sizeof (enum machine_mode));
2573   memcpy (constraints, recog_data.constraints, noperands * sizeof (char *));
2574
2575   commutative = -1;
2576
2577   /* If we will need to know, later, whether some pair of operands
2578      are the same, we must compare them now and save the result.
2579      Reloading the base and index registers will clobber them
2580      and afterward they will fail to match.  */
2581
2582   for (i = 0; i < noperands; i++)
2583     {
2584       char *p;
2585       int c;
2586
2587       substed_operand[i] = recog_data.operand[i];
2588       p = constraints[i];
2589
2590       modified[i] = RELOAD_READ;
2591
2592       /* Scan this operand's constraint to see if it is an output operand,
2593          an in-out operand, is commutative, or should match another.  */
2594
2595       while ((c = *p))
2596         {
2597           p += CONSTRAINT_LEN (c, p);
2598           if (c == '=')
2599             modified[i] = RELOAD_WRITE;
2600           else if (c == '+')
2601             modified[i] = RELOAD_READ_WRITE;
2602           else if (c == '%')
2603             {
2604               /* The last operand should not be marked commutative.  */
2605               if (i == noperands - 1)
2606                 abort ();
2607
2608               commutative = i;
2609             }
2610           else if (ISDIGIT (c))
2611             {
2612               c = strtoul (p - 1, &p, 10);
2613
2614               operands_match[c][i]
2615                 = operands_match_p (recog_data.operand[c],
2616                                     recog_data.operand[i]);
2617
2618               /* An operand may not match itself.  */
2619               if (c == i)
2620                 abort ();
2621
2622               /* If C can be commuted with C+1, and C might need to match I,
2623                  then C+1 might also need to match I.  */
2624               if (commutative >= 0)
2625                 {
2626                   if (c == commutative || c == commutative + 1)
2627                     {
2628                       int other = c + (c == commutative ? 1 : -1);
2629                       operands_match[other][i]
2630                         = operands_match_p (recog_data.operand[other],
2631                                             recog_data.operand[i]);
2632                     }
2633                   if (i == commutative || i == commutative + 1)
2634                     {
2635                       int other = i + (i == commutative ? 1 : -1);
2636                       operands_match[c][other]
2637                         = operands_match_p (recog_data.operand[c],
2638                                             recog_data.operand[other]);
2639                     }
2640                   /* Note that C is supposed to be less than I.
2641                      No need to consider altering both C and I because in
2642                      that case we would alter one into the other.  */
2643                 }
2644             }
2645         }
2646     }
2647
2648   /* Examine each operand that is a memory reference or memory address
2649      and reload parts of the addresses into index registers.
2650      Also here any references to pseudo regs that didn't get hard regs
2651      but are equivalent to constants get replaced in the insn itself
2652      with those constants.  Nobody will ever see them again.
2653
2654      Finally, set up the preferred classes of each operand.  */
2655
2656   for (i = 0; i < noperands; i++)
2657     {
2658       RTX_CODE code = GET_CODE (recog_data.operand[i]);
2659
2660       address_reloaded[i] = 0;
2661       operand_type[i] = (modified[i] == RELOAD_READ ? RELOAD_FOR_INPUT
2662                          : modified[i] == RELOAD_WRITE ? RELOAD_FOR_OUTPUT
2663                          : RELOAD_OTHER);
2664       address_type[i]
2665         = (modified[i] == RELOAD_READ ? RELOAD_FOR_INPUT_ADDRESS
2666            : modified[i] == RELOAD_WRITE ? RELOAD_FOR_OUTPUT_ADDRESS
2667            : RELOAD_OTHER);
2668
2669       if (*constraints[i] == 0)
2670         /* Ignore things like match_operator operands.  */
2671         ;
2672       else if (constraints[i][0] == 'p'
2673                || EXTRA_ADDRESS_CONSTRAINT (constraints[i][0], constraints[i]))
2674         {
2675           find_reloads_address (recog_data.operand_mode[i], (rtx*) 0,
2676                                 recog_data.operand[i],
2677                                 recog_data.operand_loc[i],
2678                                 i, operand_type[i], ind_levels, insn);
2679
2680           /* If we now have a simple operand where we used to have a
2681              PLUS or MULT, re-recognize and try again.  */
2682           if ((GET_RTX_CLASS (GET_CODE (*recog_data.operand_loc[i])) == 'o'
2683                || GET_CODE (*recog_data.operand_loc[i]) == SUBREG)
2684               && (GET_CODE (recog_data.operand[i]) == MULT
2685                   || GET_CODE (recog_data.operand[i]) == PLUS))
2686             {
2687               INSN_CODE (insn) = -1;
2688               retval = find_reloads (insn, replace, ind_levels, live_known,
2689                                      reload_reg_p);
2690               return retval;
2691             }
2692
2693           recog_data.operand[i] = *recog_data.operand_loc[i];
2694           substed_operand[i] = recog_data.operand[i];
2695         }
2696       else if (code == MEM)
2697         {
2698           address_reloaded[i]
2699             = find_reloads_address (GET_MODE (recog_data.operand[i]),
2700                                     recog_data.operand_loc[i],
2701                                     XEXP (recog_data.operand[i], 0),
2702                                     &XEXP (recog_data.operand[i], 0),
2703                                     i, address_type[i], ind_levels, insn);
2704           recog_data.operand[i] = *recog_data.operand_loc[i];
2705           substed_operand[i] = recog_data.operand[i];
2706         }
2707       else if (code == SUBREG)
2708         {
2709           rtx reg = SUBREG_REG (recog_data.operand[i]);
2710           rtx op
2711             = find_reloads_toplev (recog_data.operand[i], i, address_type[i],
2712                                    ind_levels,
2713                                    set != 0
2714                                    && &SET_DEST (set) == recog_data.operand_loc[i],
2715                                    insn,
2716                                    &address_reloaded[i]);
2717
2718           /* If we made a MEM to load (a part of) the stackslot of a pseudo
2719              that didn't get a hard register, emit a USE with a REG_EQUAL
2720              note in front so that we might inherit a previous, possibly
2721              wider reload.  */
2722
2723           if (replace
2724               && GET_CODE (op) == MEM
2725               && GET_CODE (reg) == REG
2726               && (GET_MODE_SIZE (GET_MODE (reg))
2727                   >= GET_MODE_SIZE (GET_MODE (op))))
2728             set_unique_reg_note (emit_insn_before (gen_rtx_USE (VOIDmode, reg),
2729                                                    insn),
2730                                  REG_EQUAL, reg_equiv_memory_loc[REGNO (reg)]);
2731
2732           substed_operand[i] = recog_data.operand[i] = op;
2733         }
2734       else if (code == PLUS || GET_RTX_CLASS (code) == '1')
2735         /* We can get a PLUS as an "operand" as a result of register
2736            elimination.  See eliminate_regs and gen_reload.  We handle
2737            a unary operator by reloading the operand.  */
2738         substed_operand[i] = recog_data.operand[i]
2739           = find_reloads_toplev (recog_data.operand[i], i, address_type[i],
2740                                  ind_levels, 0, insn,
2741                                  &address_reloaded[i]);
2742       else if (code == REG)
2743         {
2744           /* This is equivalent to calling find_reloads_toplev.
2745              The code is duplicated for speed.
2746              When we find a pseudo always equivalent to a constant,
2747              we replace it by the constant.  We must be sure, however,
2748              that we don't try to replace it in the insn in which it
2749              is being set.  */
2750           int regno = REGNO (recog_data.operand[i]);
2751           if (reg_equiv_constant[regno] != 0
2752               && (set == 0 || &SET_DEST (set) != recog_data.operand_loc[i]))
2753             {
2754               /* Record the existing mode so that the check if constants are
2755                  allowed will work when operand_mode isn't specified.  */
2756
2757               if (operand_mode[i] == VOIDmode)
2758                 operand_mode[i] = GET_MODE (recog_data.operand[i]);
2759
2760               substed_operand[i] = recog_data.operand[i]
2761                 = reg_equiv_constant[regno];
2762             }
2763           if (reg_equiv_memory_loc[regno] != 0
2764               && (reg_equiv_address[regno] != 0 || num_not_at_initial_offset))
2765             /* We need not give a valid is_set_dest argument since the case
2766                of a constant equivalence was checked above.  */
2767             substed_operand[i] = recog_data.operand[i]
2768               = find_reloads_toplev (recog_data.operand[i], i, address_type[i],
2769                                      ind_levels, 0, insn,
2770                                      &address_reloaded[i]);
2771         }
2772       /* If the operand is still a register (we didn't replace it with an
2773          equivalent), get the preferred class to reload it into.  */
2774       code = GET_CODE (recog_data.operand[i]);
2775       preferred_class[i]
2776         = ((code == REG && REGNO (recog_data.operand[i])
2777             >= FIRST_PSEUDO_REGISTER)
2778            ? reg_preferred_class (REGNO (recog_data.operand[i]))
2779            : NO_REGS);
2780       pref_or_nothing[i]
2781         = (code == REG
2782            && REGNO (recog_data.operand[i]) >= FIRST_PSEUDO_REGISTER
2783            && reg_alternate_class (REGNO (recog_data.operand[i])) == NO_REGS);
2784     }
2785
2786   /* If this is simply a copy from operand 1 to operand 0, merge the
2787      preferred classes for the operands.  */
2788   if (set != 0 && noperands >= 2 && recog_data.operand[0] == SET_DEST (set)
2789       && recog_data.operand[1] == SET_SRC (set))
2790     {
2791       preferred_class[0] = preferred_class[1]
2792         = reg_class_subunion[(int) preferred_class[0]][(int) preferred_class[1]];
2793       pref_or_nothing[0] |= pref_or_nothing[1];
2794       pref_or_nothing[1] |= pref_or_nothing[0];
2795     }
2796
2797   /* Now see what we need for pseudo-regs that didn't get hard regs
2798      or got the wrong kind of hard reg.  For this, we must consider
2799      all the operands together against the register constraints.  */
2800
2801   best = MAX_RECOG_OPERANDS * 2 + 600;
2802
2803   swapped = 0;
2804   goal_alternative_swapped = 0;
2805  try_swapped:
2806
2807   /* The constraints are made of several alternatives.
2808      Each operand's constraint looks like foo,bar,... with commas
2809      separating the alternatives.  The first alternatives for all
2810      operands go together, the second alternatives go together, etc.
2811
2812      First loop over alternatives.  */
2813
2814   for (this_alternative_number = 0;
2815        this_alternative_number < n_alternatives;
2816        this_alternative_number++)
2817     {
2818       /* Loop over operands for one constraint alternative.  */
2819       /* LOSERS counts those that don't fit this alternative
2820          and would require loading.  */
2821       int losers = 0;
2822       /* BAD is set to 1 if it some operand can't fit this alternative
2823          even after reloading.  */
2824       int bad = 0;
2825       /* REJECT is a count of how undesirable this alternative says it is
2826          if any reloading is required.  If the alternative matches exactly
2827          then REJECT is ignored, but otherwise it gets this much
2828          counted against it in addition to the reloading needed.  Each
2829          ? counts three times here since we want the disparaging caused by
2830          a bad register class to only count 1/3 as much.  */
2831       int reject = 0;
2832
2833       this_earlyclobber = 0;
2834
2835       for (i = 0; i < noperands; i++)
2836         {
2837           char *p = constraints[i];
2838           char *end;
2839           int len;
2840           int win = 0;
2841           int did_match = 0;
2842           /* 0 => this operand can be reloaded somehow for this alternative.  */
2843           int badop = 1;
2844           /* 0 => this operand can be reloaded if the alternative allows regs.  */
2845           int winreg = 0;
2846           int c;
2847           int m;
2848           rtx operand = recog_data.operand[i];
2849           int offset = 0;
2850           /* Nonzero means this is a MEM that must be reloaded into a reg
2851              regardless of what the constraint says.  */
2852           int force_reload = 0;
2853           int offmemok = 0;
2854           /* Nonzero if a constant forced into memory would be OK for this
2855              operand.  */
2856           int constmemok = 0;
2857           int earlyclobber = 0;
2858
2859           /* If the predicate accepts a unary operator, it means that
2860              we need to reload the operand, but do not do this for
2861              match_operator and friends.  */
2862           if (GET_RTX_CLASS (GET_CODE (operand)) == '1' && *p != 0)
2863             operand = XEXP (operand, 0);
2864
2865           /* If the operand is a SUBREG, extract
2866              the REG or MEM (or maybe even a constant) within.
2867              (Constants can occur as a result of reg_equiv_constant.)  */
2868
2869           while (GET_CODE (operand) == SUBREG)
2870             {
2871               /* Offset only matters when operand is a REG and
2872                  it is a hard reg.  This is because it is passed
2873                  to reg_fits_class_p if it is a REG and all pseudos
2874                  return 0 from that function.  */
2875               if (GET_CODE (SUBREG_REG (operand)) == REG
2876                   && REGNO (SUBREG_REG (operand)) < FIRST_PSEUDO_REGISTER)
2877                 {
2878                   offset += subreg_regno_offset (REGNO (SUBREG_REG (operand)),
2879                                                  GET_MODE (SUBREG_REG (operand)),
2880                                                  SUBREG_BYTE (operand),
2881                                                  GET_MODE (operand));
2882                 }
2883               operand = SUBREG_REG (operand);
2884               /* Force reload if this is a constant or PLUS or if there may
2885                  be a problem accessing OPERAND in the outer mode.  */
2886               if (CONSTANT_P (operand)
2887                   || GET_CODE (operand) == PLUS
2888                   /* We must force a reload of paradoxical SUBREGs
2889                      of a MEM because the alignment of the inner value
2890                      may not be enough to do the outer reference.  On
2891                      big-endian machines, it may also reference outside
2892                      the object.
2893
2894                      On machines that extend byte operations and we have a
2895                      SUBREG where both the inner and outer modes are no wider
2896                      than a word and the inner mode is narrower, is integral,
2897                      and gets extended when loaded from memory, combine.c has
2898                      made assumptions about the behavior of the machine in such
2899                      register access.  If the data is, in fact, in memory we
2900                      must always load using the size assumed to be in the
2901                      register and let the insn do the different-sized
2902                      accesses.
2903
2904                      This is doubly true if WORD_REGISTER_OPERATIONS.  In
2905                      this case eliminate_regs has left non-paradoxical
2906                      subregs for push_reloads to see.  Make sure it does
2907                      by forcing the reload.
2908
2909                      ??? When is it right at this stage to have a subreg
2910                      of a mem that is _not_ to be handled specially?  IMO
2911                      those should have been reduced to just a mem.  */
2912                   || ((GET_CODE (operand) == MEM
2913                        || (GET_CODE (operand)== REG
2914                            && REGNO (operand) >= FIRST_PSEUDO_REGISTER))
2915 #ifndef WORD_REGISTER_OPERATIONS
2916                       && (((GET_MODE_BITSIZE (GET_MODE (operand))
2917                             < BIGGEST_ALIGNMENT)
2918                            && (GET_MODE_SIZE (operand_mode[i])
2919                                > GET_MODE_SIZE (GET_MODE (operand))))
2920                           || (GET_CODE (operand) == MEM && BYTES_BIG_ENDIAN)
2921 #ifdef LOAD_EXTEND_OP
2922                           || (GET_MODE_SIZE (operand_mode[i]) <= UNITS_PER_WORD
2923                               && (GET_MODE_SIZE (GET_MODE (operand))
2924                                   <= UNITS_PER_WORD)
2925                               && (GET_MODE_SIZE (operand_mode[i])
2926                                   > GET_MODE_SIZE (GET_MODE (operand)))
2927                               && INTEGRAL_MODE_P (GET_MODE (operand))
2928                               && LOAD_EXTEND_OP (GET_MODE (operand)) != NIL)
2929 #endif
2930                           )
2931 #endif
2932                       )
2933                   /* This following hunk of code should no longer be
2934                      needed at all with SUBREG_BYTE.  If you need this
2935                      code back, please explain to me why so I can
2936                      fix the real problem.  -DaveM */
2937 #if 0
2938                   /* Subreg of a hard reg which can't handle the subreg's mode
2939                      or which would handle that mode in the wrong number of
2940                      registers for subregging to work.  */
2941                   || (GET_CODE (operand) == REG
2942                       && REGNO (operand) < FIRST_PSEUDO_REGISTER
2943                       && ((GET_MODE_SIZE (operand_mode[i]) <= UNITS_PER_WORD
2944                            && (GET_MODE_SIZE (GET_MODE (operand))
2945                                > UNITS_PER_WORD)
2946                            && ((GET_MODE_SIZE (GET_MODE (operand))
2947                                 / UNITS_PER_WORD)
2948                                != HARD_REGNO_NREGS (REGNO (operand),
2949                                                     GET_MODE (operand))))
2950                           || ! HARD_REGNO_MODE_OK (REGNO (operand) + offset,
2951                                                    operand_mode[i])))
2952 #endif
2953                   )
2954                 force_reload = 1;
2955             }
2956
2957           this_alternative[i] = (int) NO_REGS;
2958           this_alternative_win[i] = 0;
2959           this_alternative_match_win[i] = 0;
2960           this_alternative_offmemok[i] = 0;
2961           this_alternative_earlyclobber[i] = 0;
2962           this_alternative_matches[i] = -1;
2963
2964           /* An empty constraint or empty alternative
2965              allows anything which matched the pattern.  */
2966           if (*p == 0 || *p == ',')
2967             win = 1, badop = 0;
2968
2969           /* Scan this alternative's specs for this operand;
2970              set WIN if the operand fits any letter in this alternative.
2971              Otherwise, clear BADOP if this operand could
2972              fit some letter after reloads,
2973              or set WINREG if this operand could fit after reloads
2974              provided the constraint allows some registers.  */
2975
2976           do
2977             switch ((c = *p, len = CONSTRAINT_LEN (c, p)), c)
2978               {
2979               case '\0':
2980                 len = 0;
2981                 break;
2982               case ',':
2983                 c = '\0';
2984                 break;
2985
2986               case '=':  case '+':  case '*':
2987                 break;
2988
2989               case '%':
2990                 /* The last operand should not be marked commutative.  */
2991                 if (i != noperands - 1)
2992                   commutative = i;
2993                 break;
2994
2995               case '?':
2996                 reject += 6;
2997                 break;
2998
2999               case '!':
3000                 reject = 600;
3001                 break;
3002
3003               case '#':
3004                 /* Ignore rest of this alternative as far as
3005                    reloading is concerned.  */
3006                 do
3007                   p++;
3008                 while (*p && *p != ',');
3009                 len = 0;
3010                 break;
3011
3012               case '0':  case '1':  case '2':  case '3':  case '4':
3013               case '5':  case '6':  case '7':  case '8':  case '9':
3014                 m = strtoul (p, &end, 10);
3015                 p = end;
3016                 len = 0;
3017
3018                 this_alternative_matches[i] = m;
3019                 /* We are supposed to match a previous operand.
3020                    If we do, we win if that one did.
3021                    If we do not, count both of the operands as losers.
3022                    (This is too conservative, since most of the time
3023                    only a single reload insn will be needed to make
3024                    the two operands win.  As a result, this alternative
3025                    may be rejected when it is actually desirable.)  */
3026                 if ((swapped && (m != commutative || i != commutative + 1))
3027                     /* If we are matching as if two operands were swapped,
3028                        also pretend that operands_match had been computed
3029                        with swapped.
3030                        But if I is the second of those and C is the first,
3031                        don't exchange them, because operands_match is valid
3032                        only on one side of its diagonal.  */
3033                     ? (operands_match
3034                        [(m == commutative || m == commutative + 1)
3035                        ? 2 * commutative + 1 - m : m]
3036                        [(i == commutative || i == commutative + 1)
3037                        ? 2 * commutative + 1 - i : i])
3038                     : operands_match[m][i])
3039                   {
3040                     /* If we are matching a non-offsettable address where an
3041                        offsettable address was expected, then we must reject
3042                        this combination, because we can't reload it.  */
3043                     if (this_alternative_offmemok[m]
3044                         && GET_CODE (recog_data.operand[m]) == MEM
3045                         && this_alternative[m] == (int) NO_REGS
3046                         && ! this_alternative_win[m])
3047                       bad = 1;
3048
3049                     did_match = this_alternative_win[m];
3050                   }
3051                 else
3052                   {
3053                     /* Operands don't match.  */
3054                     rtx value;
3055                     /* Retroactively mark the operand we had to match
3056                        as a loser, if it wasn't already.  */
3057                     if (this_alternative_win[m])
3058                       losers++;
3059                     this_alternative_win[m] = 0;
3060                     if (this_alternative[m] == (int) NO_REGS)
3061                       bad = 1;
3062                     /* But count the pair only once in the total badness of
3063                        this alternative, if the pair can be a dummy reload.  */
3064                     value
3065                       = find_dummy_reload (recog_data.operand[i],
3066                                            recog_data.operand[m],
3067                                            recog_data.operand_loc[i],
3068                                            recog_data.operand_loc[m],
3069                                            operand_mode[i], operand_mode[m],
3070                                            this_alternative[m], -1,
3071                                            this_alternative_earlyclobber[m]);
3072
3073                     if (value != 0)
3074                       losers--;
3075                   }
3076                 /* This can be fixed with reloads if the operand
3077                    we are supposed to match can be fixed with reloads.  */
3078                 badop = 0;
3079                 this_alternative[i] = this_alternative[m];
3080
3081                 /* If we have to reload this operand and some previous
3082                    operand also had to match the same thing as this
3083                    operand, we don't know how to do that.  So reject this
3084                    alternative.  */
3085                 if (! did_match || force_reload)
3086                   for (j = 0; j < i; j++)
3087                     if (this_alternative_matches[j]
3088                         == this_alternative_matches[i])
3089                       badop = 1;
3090                 break;
3091
3092               case 'p':
3093                 /* All necessary reloads for an address_operand
3094                    were handled in find_reloads_address.  */
3095                 this_alternative[i] = (int) MODE_BASE_REG_CLASS (VOIDmode);
3096                 win = 1;
3097                 badop = 0;
3098                 break;
3099
3100               case 'm':
3101                 if (force_reload)
3102                   break;
3103                 if (GET_CODE (operand) == MEM
3104                     || (GET_CODE (operand) == REG
3105                         && REGNO (operand) >= FIRST_PSEUDO_REGISTER
3106                         && reg_renumber[REGNO (operand)] < 0))
3107                   win = 1;
3108                 if (CONSTANT_P (operand)
3109                     /* force_const_mem does not accept HIGH.  */
3110                     && GET_CODE (operand) != HIGH)
3111                   badop = 0;
3112                 constmemok = 1;
3113                 break;
3114
3115               case '<':
3116                 if (GET_CODE (operand) == MEM
3117                     && ! address_reloaded[i]
3118                     && (GET_CODE (XEXP (operand, 0)) == PRE_DEC
3119                         || GET_CODE (XEXP (operand, 0)) == POST_DEC))
3120                   win = 1;
3121                 break;
3122
3123               case '>':
3124                 if (GET_CODE (operand) == MEM
3125                     && ! address_reloaded[i]
3126                     && (GET_CODE (XEXP (operand, 0)) == PRE_INC
3127                         || GET_CODE (XEXP (operand, 0)) == POST_INC))
3128                   win = 1;
3129                 break;
3130
3131                 /* Memory operand whose address is not offsettable.  */
3132               case 'V':
3133                 if (force_reload)
3134                   break;
3135                 if (GET_CODE (operand) == MEM
3136                     && ! (ind_levels ? offsettable_memref_p (operand)
3137                           : offsettable_nonstrict_memref_p (operand))
3138                     /* Certain mem addresses will become offsettable
3139                        after they themselves are reloaded.  This is important;
3140                        we don't want our own handling of unoffsettables
3141                        to override the handling of reg_equiv_address.  */
3142                     && !(GET_CODE (XEXP (operand, 0)) == REG
3143                          && (ind_levels == 0
3144                              || reg_equiv_address[REGNO (XEXP (operand, 0))] != 0)))
3145                   win = 1;
3146                 break;
3147
3148                 /* Memory operand whose address is offsettable.  */
3149               case 'o':
3150                 if (force_reload)
3151                   break;
3152                 if ((GET_CODE (operand) == MEM
3153                      /* If IND_LEVELS, find_reloads_address won't reload a
3154                         pseudo that didn't get a hard reg, so we have to
3155                         reject that case.  */
3156                      && ((ind_levels ? offsettable_memref_p (operand)
3157                           : offsettable_nonstrict_memref_p (operand))
3158                          /* A reloaded address is offsettable because it is now
3159                             just a simple register indirect.  */
3160                          || address_reloaded[i]))
3161                     || (GET_CODE (operand) == REG
3162                         && REGNO (operand) >= FIRST_PSEUDO_REGISTER
3163                         && reg_renumber[REGNO (operand)] < 0
3164                         /* If reg_equiv_address is nonzero, we will be
3165                            loading it into a register; hence it will be
3166                            offsettable, but we cannot say that reg_equiv_mem
3167                            is offsettable without checking.  */
3168                         && ((reg_equiv_mem[REGNO (operand)] != 0
3169                              && offsettable_memref_p (reg_equiv_mem[REGNO (operand)]))
3170                             || (reg_equiv_address[REGNO (operand)] != 0))))
3171                   win = 1;
3172                 /* force_const_mem does not accept HIGH.  */
3173                 if ((CONSTANT_P (operand) && GET_CODE (operand) != HIGH)
3174                     || GET_CODE (operand) == MEM)
3175                   badop = 0;
3176                 constmemok = 1;
3177                 offmemok = 1;
3178                 break;
3179
3180               case '&':
3181                 /* Output operand that is stored before the need for the
3182                    input operands (and their index registers) is over.  */
3183                 earlyclobber = 1, this_earlyclobber = 1;
3184                 break;
3185
3186               case 'E':
3187               case 'F':
3188                 if (GET_CODE (operand) == CONST_DOUBLE
3189                     || (GET_CODE (operand) == CONST_VECTOR
3190                         && (GET_MODE_CLASS (GET_MODE (operand))
3191                             == MODE_VECTOR_FLOAT)))
3192                   win = 1;
3193                 break;
3194
3195               case 'G':
3196               case 'H':
3197                 if (GET_CODE (operand) == CONST_DOUBLE
3198                     && CONST_DOUBLE_OK_FOR_CONSTRAINT_P (operand, c, p))
3199                   win = 1;
3200                 break;
3201
3202               case 's':
3203                 if (GET_CODE (operand) == CONST_INT
3204                     || (GET_CODE (operand) == CONST_DOUBLE
3205                         && GET_MODE (operand) == VOIDmode))
3206                   break;
3207               case 'i':
3208                 if (CONSTANT_P (operand)
3209 #ifdef LEGITIMATE_PIC_OPERAND_P
3210                     && (! flag_pic || LEGITIMATE_PIC_OPERAND_P (operand))
3211 #endif
3212                     )
3213                   win = 1;
3214                 break;
3215
3216               case 'n':
3217                 if (GET_CODE (operand) == CONST_INT
3218                     || (GET_CODE (operand) == CONST_DOUBLE
3219                         && GET_MODE (operand) == VOIDmode))
3220                   win = 1;
3221                 break;
3222
3223               case 'I':
3224               case 'J':
3225               case 'K':
3226               case 'L':
3227               case 'M':
3228               case 'N':
3229               case 'O':
3230               case 'P':
3231                 if (GET_CODE (operand) == CONST_INT
3232                     && CONST_OK_FOR_CONSTRAINT_P (INTVAL (operand), c, p))
3233                   win = 1;
3234                 break;
3235
3236               case 'X':
3237                 win = 1;
3238                 break;
3239
3240               case 'g':
3241                 if (! force_reload
3242                     /* A PLUS is never a valid operand, but reload can make
3243                        it from a register when eliminating registers.  */
3244                     && GET_CODE (operand) != PLUS
3245                     /* A SCRATCH is not a valid operand.  */
3246                     && GET_CODE (operand) != SCRATCH
3247 #ifdef LEGITIMATE_PIC_OPERAND_P
3248                     && (! CONSTANT_P (operand)
3249                         || ! flag_pic
3250                         || LEGITIMATE_PIC_OPERAND_P (operand))
3251 #endif
3252                     && (GENERAL_REGS == ALL_REGS
3253                         || GET_CODE (operand) != REG
3254                         || (REGNO (operand) >= FIRST_PSEUDO_REGISTER
3255                             && reg_renumber[REGNO (operand)] < 0)))
3256                   win = 1;
3257                 /* Drop through into 'r' case.  */
3258
3259               case 'r':
3260                 this_alternative[i]
3261                   = (int) reg_class_subunion[this_alternative[i]][(int) GENERAL_REGS];
3262                 goto reg;
3263
3264               default:
3265                 if (REG_CLASS_FROM_CONSTRAINT (c, p) == NO_REGS)
3266                   {
3267 #ifdef EXTRA_CONSTRAINT_STR
3268                     if (EXTRA_MEMORY_CONSTRAINT (c, p))
3269                       {
3270                         if (force_reload)
3271                           break;
3272                         if (EXTRA_CONSTRAINT_STR (operand, c, p))
3273                           win = 1;
3274                         /* If the address was already reloaded,
3275                            we win as well.  */
3276                         if (GET_CODE (operand) == MEM && address_reloaded[i])
3277                           win = 1;
3278                         /* Likewise if the address will be reloaded because
3279                            reg_equiv_address is nonzero.  For reg_equiv_mem
3280                            we have to check.  */
3281                         if (GET_CODE (operand) == REG
3282                             && REGNO (operand) >= FIRST_PSEUDO_REGISTER
3283                             && reg_renumber[REGNO (operand)] < 0
3284                             && ((reg_equiv_mem[REGNO (operand)] != 0
3285                                  && EXTRA_CONSTRAINT_STR (reg_equiv_mem[REGNO (operand)], c, p))
3286                                 || (reg_equiv_address[REGNO (operand)] != 0)))
3287                           win = 1;
3288
3289                         /* If we didn't already win, we can reload
3290                            constants via force_const_mem, and other
3291                            MEMs by reloading the address like for 'o'.  */
3292                         if ((CONSTANT_P (operand) && GET_CODE (operand) != HIGH)
3293                             || GET_CODE (operand) == MEM)
3294                           badop = 0;
3295                         constmemok = 1;
3296                         offmemok = 1;
3297                         break;
3298                       }
3299                     if (EXTRA_ADDRESS_CONSTRAINT (c, p))
3300                       {
3301                         if (EXTRA_CONSTRAINT_STR (operand, c, p))
3302                           win = 1;
3303
3304                         /* If we didn't already win, we can reload
3305                            the address into a base register.  */
3306                         this_alternative[i] = (int) MODE_BASE_REG_CLASS (VOIDmode);
3307                         badop = 0;
3308
3309                         /* Address constraints are reloaded in Pmode, no matter
3310                            what mode is given in the machine description.  */
3311                         operand_mode[i] = Pmode;
3312                         break;
3313                       }
3314
3315                     if (EXTRA_CONSTRAINT_STR (operand, c, p))
3316                       win = 1;
3317 #endif
3318                     break;
3319                   }
3320
3321                 this_alternative[i]
3322                   = (int) (reg_class_subunion
3323                            [this_alternative[i]]
3324                            [(int) REG_CLASS_FROM_CONSTRAINT (c, p)]);
3325               reg:
3326                 if (GET_MODE (operand) == BLKmode)
3327                   break;
3328                 winreg = 1;
3329                 if (GET_CODE (operand) == REG
3330                     && reg_fits_class_p (operand, this_alternative[i],
3331                                          offset, GET_MODE (recog_data.operand[i])))
3332                   win = 1;
3333                 break;
3334               }
3335           while ((p += len), c);
3336
3337           constraints[i] = p;
3338
3339           /* If this operand could be handled with a reg,
3340              and some reg is allowed, then this operand can be handled.  */
3341           if (winreg && this_alternative[i] != (int) NO_REGS)
3342             badop = 0;
3343
3344           /* Record which operands fit this alternative.  */
3345           this_alternative_earlyclobber[i] = earlyclobber;
3346           if (win && ! force_reload)
3347             this_alternative_win[i] = 1;
3348           else if (did_match && ! force_reload)
3349             this_alternative_match_win[i] = 1;
3350           else
3351             {
3352               int const_to_mem = 0;
3353
3354               this_alternative_offmemok[i] = offmemok;
3355               losers++;
3356               if (badop)
3357                 bad = 1;
3358               /* Alternative loses if it has no regs for a reg operand.  */
3359               if (GET_CODE (operand) == REG
3360                   && this_alternative[i] == (int) NO_REGS
3361                   && this_alternative_matches[i] < 0)
3362                 bad = 1;
3363
3364               /* If this is a constant that is reloaded into the desired
3365                  class by copying it to memory first, count that as another
3366                  reload.  This is consistent with other code and is
3367                  required to avoid choosing another alternative when
3368                  the constant is moved into memory by this function on
3369                  an early reload pass.  Note that the test here is
3370                  precisely the same as in the code below that calls
3371                  force_const_mem.  */
3372               if (CONSTANT_P (operand)
3373                   /* force_const_mem does not accept HIGH.  */
3374                   && GET_CODE (operand) != HIGH
3375                   && ((PREFERRED_RELOAD_CLASS (operand,
3376                                                (enum reg_class) this_alternative[i])
3377                        == NO_REGS)
3378                       || no_input_reloads)
3379                   && operand_mode[i] != VOIDmode)
3380                 {
3381                   const_to_mem = 1;
3382                   if (this_alternative[i] != (int) NO_REGS)
3383                     losers++;
3384                 }
3385
3386               /* If we can't reload this value at all, reject this
3387                  alternative.  Note that we could also lose due to
3388                  LIMIT_RELOAD_RELOAD_CLASS, but we don't check that
3389                  here.  */
3390
3391               if (! CONSTANT_P (operand)
3392                   && (enum reg_class) this_alternative[i] != NO_REGS
3393                   && (PREFERRED_RELOAD_CLASS (operand,
3394                                               (enum reg_class) this_alternative[i])
3395                       == NO_REGS))
3396                 bad = 1;
3397
3398               /* Alternative loses if it requires a type of reload not
3399                  permitted for this insn.  We can always reload SCRATCH
3400                  and objects with a REG_UNUSED note.  */
3401               else if (GET_CODE (operand) != SCRATCH
3402                        && modified[i] != RELOAD_READ && no_output_reloads
3403                        && ! find_reg_note (insn, REG_UNUSED, operand))
3404                 bad = 1;
3405               else if (modified[i] != RELOAD_WRITE && no_input_reloads
3406                        && ! const_to_mem)
3407                 bad = 1;
3408
3409               /* We prefer to reload pseudos over reloading other things,
3410                  since such reloads may be able to be eliminated later.
3411                  If we are reloading a SCRATCH, we won't be generating any
3412                  insns, just using a register, so it is also preferred.
3413                  So bump REJECT in other cases.  Don't do this in the
3414                  case where we are forcing a constant into memory and
3415                  it will then win since we don't want to have a different
3416                  alternative match then.  */
3417               if (! (GET_CODE (operand) == REG
3418                      && REGNO (operand) >= FIRST_PSEUDO_REGISTER)
3419                   && GET_CODE (operand) != SCRATCH
3420                   && ! (const_to_mem && constmemok))
3421                 reject += 2;
3422
3423               /* Input reloads can be inherited more often than output
3424                  reloads can be removed, so penalize output reloads.  */
3425               if (operand_type[i] != RELOAD_FOR_INPUT
3426                   && GET_CODE (operand) != SCRATCH)
3427                 reject++;
3428             }
3429
3430           /* If this operand is a pseudo register that didn't get a hard
3431              reg and this alternative accepts some register, see if the
3432              class that we want is a subset of the preferred class for this
3433              register.  If not, but it intersects that class, use the
3434              preferred class instead.  If it does not intersect the preferred
3435              class, show that usage of this alternative should be discouraged;
3436              it will be discouraged more still if the register is `preferred
3437              or nothing'.  We do this because it increases the chance of
3438              reusing our spill register in a later insn and avoiding a pair
3439              of memory stores and loads.
3440
3441              Don't bother with this if this alternative will accept this
3442              operand.
3443
3444              Don't do this for a multiword operand, since it is only a
3445              small win and has the risk of requiring more spill registers,
3446              which could cause a large loss.
3447
3448              Don't do this if the preferred class has only one register
3449              because we might otherwise exhaust the class.  */
3450
3451           if (! win && ! did_match
3452               && this_alternative[i] != (int) NO_REGS
3453               && GET_MODE_SIZE (operand_mode[i]) <= UNITS_PER_WORD
3454               && reg_class_size[(int) preferred_class[i]] > 1)
3455             {
3456               if (! reg_class_subset_p (this_alternative[i],
3457                                         preferred_class[i]))
3458                 {
3459                   /* Since we don't have a way of forming the intersection,
3460                      we just do something special if the preferred class
3461                      is a subset of the class we have; that's the most
3462                      common case anyway.  */
3463                   if (reg_class_subset_p (preferred_class[i],
3464                                           this_alternative[i]))
3465                     this_alternative[i] = (int) preferred_class[i];
3466                   else
3467                     reject += (2 + 2 * pref_or_nothing[i]);
3468                 }
3469             }
3470         }
3471
3472       /* Now see if any output operands that are marked "earlyclobber"
3473          in this alternative conflict with any input operands
3474          or any memory addresses.  */
3475
3476       for (i = 0; i < noperands; i++)
3477         if (this_alternative_earlyclobber[i]
3478             && (this_alternative_win[i] || this_alternative_match_win[i]))
3479           {
3480             struct decomposition early_data;
3481
3482             early_data = decompose (recog_data.operand[i]);
3483
3484             if (modified[i] == RELOAD_READ)
3485               abort ();
3486
3487             if (this_alternative[i] == NO_REGS)
3488               {
3489                 this_alternative_earlyclobber[i] = 0;
3490                 if (this_insn_is_asm)
3491                   error_for_asm (this_insn,
3492                                  "`&' constraint used with no register class");
3493                 else
3494                   abort ();
3495               }
3496
3497             for (j = 0; j < noperands; j++)
3498               /* Is this an input operand or a memory ref?  */
3499               if ((GET_CODE (recog_data.operand[j]) == MEM
3500                    || modified[j] != RELOAD_WRITE)
3501                   && j != i
3502                   /* Ignore things like match_operator operands.  */
3503                   && *recog_data.constraints[j] != 0
3504                   /* Don't count an input operand that is constrained to match
3505                      the early clobber operand.  */
3506                   && ! (this_alternative_matches[j] == i
3507                         && rtx_equal_p (recog_data.operand[i],
3508                                         recog_data.operand[j]))
3509                   /* Is it altered by storing the earlyclobber operand?  */
3510                   && !immune_p (recog_data.operand[j], recog_data.operand[i],
3511                                 early_data))
3512                 {
3513                   /* If the output is in a single-reg class,
3514                      it's costly to reload it, so reload the input instead.  */
3515                   if (reg_class_size[this_alternative[i]] == 1
3516                       && (GET_CODE (recog_data.operand[j]) == REG
3517                           || GET_CODE (recog_data.operand[j]) == SUBREG))
3518                     {
3519                       losers++;
3520                       this_alternative_win[j] = 0;
3521                       this_alternative_match_win[j] = 0;
3522                     }
3523                   else
3524                     break;
3525                 }
3526             /* If an earlyclobber operand conflicts with something,
3527                it must be reloaded, so request this and count the cost.  */
3528             if (j != noperands)
3529               {
3530                 losers++;
3531                 this_alternative_win[i] = 0;
3532                 this_alternative_match_win[j] = 0;
3533                 for (j = 0; j < noperands; j++)
3534                   if (this_alternative_matches[j] == i
3535                       && this_alternative_match_win[j])
3536                     {
3537                       this_alternative_win[j] = 0;
3538                       this_alternative_match_win[j] = 0;
3539                       losers++;
3540                     }
3541               }
3542           }
3543
3544       /* If one alternative accepts all the operands, no reload required,
3545          choose that alternative; don't consider the remaining ones.  */
3546       if (losers == 0)
3547         {
3548           /* Unswap these so that they are never swapped at `finish'.  */
3549           if (commutative >= 0)
3550             {
3551               recog_data.operand[commutative] = substed_operand[commutative];
3552               recog_data.operand[commutative + 1]
3553                 = substed_operand[commutative + 1];
3554             }
3555           for (i = 0; i < noperands; i++)
3556             {
3557               goal_alternative_win[i] = this_alternative_win[i];
3558               goal_alternative_match_win[i] = this_alternative_match_win[i];
3559               goal_alternative[i] = this_alternative[i];
3560               goal_alternative_offmemok[i] = this_alternative_offmemok[i];
3561               goal_alternative_matches[i] = this_alternative_matches[i];
3562               goal_alternative_earlyclobber[i]
3563                 = this_alternative_earlyclobber[i];
3564             }
3565           goal_alternative_number = this_alternative_number;
3566           goal_alternative_swapped = swapped;
3567           goal_earlyclobber = this_earlyclobber;
3568           goto finish;
3569         }
3570
3571       /* REJECT, set by the ! and ? constraint characters and when a register
3572          would be reloaded into a non-preferred class, discourages the use of
3573          this alternative for a reload goal.  REJECT is incremented by six
3574          for each ? and two for each non-preferred class.  */
3575       losers = losers * 6 + reject;
3576
3577       /* If this alternative can be made to work by reloading,
3578          and it needs less reloading than the others checked so far,
3579          record it as the chosen goal for reloading.  */
3580       if (! bad && best > losers)
3581         {
3582           for (i = 0; i < noperands; i++)
3583             {
3584               goal_alternative[i] = this_alternative[i];
3585               goal_alternative_win[i] = this_alternative_win[i];
3586               goal_alternative_match_win[i] = this_alternative_match_win[i];
3587               goal_alternative_offmemok[i] = this_alternative_offmemok[i];
3588               goal_alternative_matches[i] = this_alternative_matches[i];
3589               goal_alternative_earlyclobber[i]
3590                 = this_alternative_earlyclobber[i];
3591             }
3592           goal_alternative_swapped = swapped;
3593           best = losers;
3594           goal_alternative_number = this_alternative_number;
3595           goal_earlyclobber = this_earlyclobber;
3596         }
3597     }
3598
3599   /* If insn is commutative (it's safe to exchange a certain pair of operands)
3600      then we need to try each alternative twice,
3601      the second time matching those two operands
3602      as if we had exchanged them.
3603      To do this, really exchange them in operands.
3604
3605      If we have just tried the alternatives the second time,
3606      return operands to normal and drop through.  */
3607
3608   if (commutative >= 0)
3609     {
3610       swapped = !swapped;
3611       if (swapped)
3612         {
3613           enum reg_class tclass;
3614           int t;
3615
3616           recog_data.operand[commutative] = substed_operand[commutative + 1];
3617           recog_data.operand[commutative + 1] = substed_operand[commutative];
3618           /* Swap the duplicates too.  */
3619           for (i = 0; i < recog_data.n_dups; i++)
3620             if (recog_data.dup_num[i] == commutative
3621                 || recog_data.dup_num[i] == commutative + 1)
3622               *recog_data.dup_loc[i]
3623                  = recog_data.operand[(int) recog_data.dup_num[i]];
3624
3625           tclass = preferred_class[commutative];
3626           preferred_class[commutative] = preferred_class[commutative + 1];
3627           preferred_class[commutative + 1] = tclass;
3628
3629           t = pref_or_nothing[commutative];
3630           pref_or_nothing[commutative] = pref_or_nothing[commutative + 1];
3631           pref_or_nothing[commutative + 1] = t;
3632
3633           memcpy (constraints, recog_data.constraints,
3634                   noperands * sizeof (char *));
3635           goto try_swapped;
3636         }
3637       else
3638         {
3639           recog_data.operand[commutative] = substed_operand[commutative];
3640           recog_data.operand[commutative + 1]
3641             = substed_operand[commutative + 1];
3642           /* Unswap the duplicates too.  */
3643           for (i = 0; i < recog_data.n_dups; i++)
3644             if (recog_data.dup_num[i] == commutative
3645                 || recog_data.dup_num[i] == commutative + 1)
3646               *recog_data.dup_loc[i]
3647                  = recog_data.operand[(int) recog_data.dup_num[i]];
3648         }
3649     }
3650
3651   /* The operands don't meet the constraints.
3652      goal_alternative describes the alternative
3653      that we could reach by reloading the fewest operands.
3654      Reload so as to fit it.  */
3655
3656   if (best == MAX_RECOG_OPERANDS * 2 + 600)
3657     {
3658       /* No alternative works with reloads??  */
3659       if (insn_code_number >= 0)
3660         fatal_insn ("unable to generate reloads for:", insn);
3661       error_for_asm (insn, "inconsistent operand constraints in an `asm'");
3662       /* Avoid further trouble with this insn.  */
3663       PATTERN (insn) = gen_rtx_USE (VOIDmode, const0_rtx);
3664       n_reloads = 0;
3665       return 0;
3666     }
3667
3668   /* Jump to `finish' from above if all operands are valid already.
3669      In that case, goal_alternative_win is all 1.  */
3670  finish:
3671
3672   /* Right now, for any pair of operands I and J that are required to match,
3673      with I < J,
3674      goal_alternative_matches[J] is I.
3675      Set up goal_alternative_matched as the inverse function:
3676      goal_alternative_matched[I] = J.  */
3677
3678   for (i = 0; i < noperands; i++)
3679     goal_alternative_matched[i] = -1;
3680
3681   for (i = 0; i < noperands; i++)
3682     if (! goal_alternative_win[i]
3683         && goal_alternative_matches[i] >= 0)
3684       goal_alternative_matched[goal_alternative_matches[i]] = i;
3685
3686   for (i = 0; i < noperands; i++)
3687     goal_alternative_win[i] |= goal_alternative_match_win[i];
3688
3689   /* If the best alternative is with operands 1 and 2 swapped,
3690      consider them swapped before reporting the reloads.  Update the
3691      operand numbers of any reloads already pushed.  */
3692
3693   if (goal_alternative_swapped)
3694     {
3695       rtx tem;
3696
3697       tem = substed_operand[commutative];
3698       substed_operand[commutative] = substed_operand[commutative + 1];
3699       substed_operand[commutative + 1] = tem;
3700       tem = recog_data.operand[commutative];
3701       recog_data.operand[commutative] = recog_data.operand[commutative + 1];
3702       recog_data.operand[commutative + 1] = tem;
3703       tem = *recog_data.operand_loc[commutative];
3704       *recog_data.operand_loc[commutative]
3705         = *recog_data.operand_loc[commutative + 1];
3706       *recog_data.operand_loc[commutative + 1] = tem;
3707
3708       for (i = 0; i < n_reloads; i++)
3709         {
3710           if (rld[i].opnum == commutative)
3711             rld[i].opnum = commutative + 1;
3712           else if (rld[i].opnum == commutative + 1)
3713             rld[i].opnum = commutative;
3714         }
3715     }
3716
3717   for (i = 0; i < noperands; i++)
3718     {
3719       operand_reloadnum[i] = -1;
3720
3721       /* If this is an earlyclobber operand, we need to widen the scope.
3722          The reload must remain valid from the start of the insn being
3723          reloaded until after the operand is stored into its destination.
3724          We approximate this with RELOAD_OTHER even though we know that we
3725          do not conflict with RELOAD_FOR_INPUT_ADDRESS reloads.
3726
3727          One special case that is worth checking is when we have an
3728          output that is earlyclobber but isn't used past the insn (typically
3729          a SCRATCH).  In this case, we only need have the reload live
3730          through the insn itself, but not for any of our input or output
3731          reloads.
3732          But we must not accidentally narrow the scope of an existing
3733          RELOAD_OTHER reload - leave these alone.
3734
3735          In any case, anything needed to address this operand can remain
3736          however they were previously categorized.  */
3737
3738       if (goal_alternative_earlyclobber[i] && operand_type[i] != RELOAD_OTHER)
3739         operand_type[i]
3740           = (find_reg_note (insn, REG_UNUSED, recog_data.operand[i])
3741              ? RELOAD_FOR_INSN : RELOAD_OTHER);
3742     }
3743
3744   /* Any constants that aren't allowed and can't be reloaded
3745      into registers are here changed into memory references.  */
3746   for (i = 0; i < noperands; i++)
3747     if (! goal_alternative_win[i]
3748         && CONSTANT_P (recog_data.operand[i])
3749         /* force_const_mem does not accept HIGH.  */
3750         && GET_CODE (recog_data.operand[i]) != HIGH
3751         && ((PREFERRED_RELOAD_CLASS (recog_data.operand[i],
3752                                      (enum reg_class) goal_alternative[i])
3753              == NO_REGS)
3754             || no_input_reloads)
3755         && operand_mode[i] != VOIDmode)
3756       {
3757         substed_operand[i] = recog_data.operand[i]
3758           = find_reloads_toplev (force_const_mem (operand_mode[i],
3759                                                   recog_data.operand[i]),
3760                                  i, address_type[i], ind_levels, 0, insn,
3761                                  NULL);
3762         if (alternative_allows_memconst (recog_data.constraints[i],
3763                                          goal_alternative_number))
3764           goal_alternative_win[i] = 1;
3765       }
3766
3767   /* Record the values of the earlyclobber operands for the caller.  */
3768   if (goal_earlyclobber)
3769     for (i = 0; i < noperands; i++)
3770       if (goal_alternative_earlyclobber[i])
3771         reload_earlyclobbers[n_earlyclobbers++] = recog_data.operand[i];
3772
3773   /* Now record reloads for all the operands that need them.  */
3774   for (i = 0; i < noperands; i++)
3775     if (! goal_alternative_win[i])
3776       {
3777         /* Operands that match previous ones have already been handled.  */
3778         if (goal_alternative_matches[i] >= 0)
3779           ;
3780         /* Handle an operand with a nonoffsettable address
3781            appearing where an offsettable address will do
3782            by reloading the address into a base register.
3783
3784            ??? We can also do this when the operand is a register and
3785            reg_equiv_mem is not offsettable, but this is a bit tricky,
3786            so we don't bother with it.  It may not be worth doing.  */
3787         else if (goal_alternative_matched[i] == -1
3788                  && goal_alternative_offmemok[i]
3789                  && GET_CODE (recog_data.operand[i]) == MEM)
3790           {
3791             operand_reloadnum[i]
3792               = push_reload (XEXP (recog_data.operand[i], 0), NULL_RTX,
3793                              &XEXP (recog_data.operand[i], 0), (rtx*) 0,
3794                              MODE_BASE_REG_CLASS (VOIDmode),
3795                              GET_MODE (XEXP (recog_data.operand[i], 0)),
3796                              VOIDmode, 0, 0, i, RELOAD_FOR_INPUT);
3797             rld[operand_reloadnum[i]].inc
3798               = GET_MODE_SIZE (GET_MODE (recog_data.operand[i]));
3799
3800             /* If this operand is an output, we will have made any
3801                reloads for its address as RELOAD_FOR_OUTPUT_ADDRESS, but
3802                now we are treating part of the operand as an input, so
3803                we must change these to RELOAD_FOR_INPUT_ADDRESS.  */
3804
3805             if (modified[i] == RELOAD_WRITE)
3806               {
3807                 for (j = 0; j < n_reloads; j++)
3808                   {
3809                     if (rld[j].opnum == i)
3810                       {
3811                         if (rld[j].when_needed == RELOAD_FOR_OUTPUT_ADDRESS)
3812                           rld[j].when_needed = RELOAD_FOR_INPUT_ADDRESS;
3813                         else if (rld[j].when_needed
3814                                  == RELOAD_FOR_OUTADDR_ADDRESS)
3815                           rld[j].when_needed = RELOAD_FOR_INPADDR_ADDRESS;
3816                       }
3817                   }
3818               }
3819           }
3820         else if (goal_alternative_matched[i] == -1)
3821           {
3822             operand_reloadnum[i]
3823               = push_reload ((modified[i] != RELOAD_WRITE
3824                               ? recog_data.operand[i] : 0),
3825                              (modified[i] != RELOAD_READ
3826                               ? recog_data.operand[i] : 0),
3827                              (modified[i] != RELOAD_WRITE
3828                               ? recog_data.operand_loc[i] : 0),
3829                              (modified[i] != RELOAD_READ
3830                               ? recog_data.operand_loc[i] : 0),
3831                              (enum reg_class) goal_alternative[i],
3832                              (modified[i] == RELOAD_WRITE
3833                               ? VOIDmode : operand_mode[i]),
3834                              (modified[i] == RELOAD_READ
3835                               ? VOIDmode : operand_mode[i]),
3836                              (insn_code_number < 0 ? 0
3837                               : insn_data[insn_code_number].operand[i].strict_low),
3838                              0, i, operand_type[i]);
3839           }
3840         /* In a matching pair of operands, one must be input only
3841            and the other must be output only.
3842            Pass the input operand as IN and the other as OUT.  */
3843         else if (modified[i] == RELOAD_READ
3844                  && modified[goal_alternative_matched[i]] == RELOAD_WRITE)
3845           {
3846             operand_reloadnum[i]
3847               = push_reload (recog_data.operand[i],
3848                              recog_data.operand[goal_alternative_matched[i]],
3849                              recog_data.operand_loc[i],
3850                              recog_data.operand_loc[goal_alternative_matched[i]],
3851                              (enum reg_class) goal_alternative[i],
3852                              operand_mode[i],
3853                              operand_mode[goal_alternative_matched[i]],
3854                              0, 0, i, RELOAD_OTHER);
3855             operand_reloadnum[goal_alternative_matched[i]] = output_reloadnum;
3856           }
3857         else if (modified[i] == RELOAD_WRITE
3858                  && modified[goal_alternative_matched[i]] == RELOAD_READ)
3859           {
3860             operand_reloadnum[goal_alternative_matched[i]]
3861               = push_reload (recog_data.operand[goal_alternative_matched[i]],
3862                              recog_data.operand[i],
3863                              recog_data.operand_loc[goal_alternative_matched[i]],
3864                              recog_data.operand_loc[i],
3865                              (enum reg_class) goal_alternative[i],
3866                              operand_mode[goal_alternative_matched[i]],
3867                              operand_mode[i],
3868                              0, 0, i, RELOAD_OTHER);
3869             operand_reloadnum[i] = output_reloadnum;
3870           }
3871         else if (insn_code_number >= 0)
3872           abort ();
3873         else
3874           {
3875             error_for_asm (insn, "inconsistent operand constraints in an `asm'");
3876             /* Avoid further trouble with this insn.  */
3877             PATTERN (insn) = gen_rtx_USE (VOIDmode, const0_rtx);
3878             n_reloads = 0;
3879             return 0;
3880           }
3881       }
3882     else if (goal_alternative_matched[i] < 0
3883              && goal_alternative_matches[i] < 0
3884              && optimize)
3885       {
3886         /* For each non-matching operand that's a MEM or a pseudo-register
3887            that didn't get a hard register, make an optional reload.
3888            This may get done even if the insn needs no reloads otherwise.  */
3889
3890         rtx operand = recog_data.operand[i];
3891
3892         while (GET_CODE (operand) == SUBREG)
3893           operand = SUBREG_REG (operand);
3894         if ((GET_CODE (operand) == MEM
3895              || (GET_CODE (operand) == REG
3896                  && REGNO (operand) >= FIRST_PSEUDO_REGISTER))
3897             /* If this is only for an output, the optional reload would not
3898                actually cause us to use a register now, just note that
3899                something is stored here.  */
3900             && ((enum reg_class) goal_alternative[i] != NO_REGS
3901                 || modified[i] == RELOAD_WRITE)
3902             && ! no_input_reloads
3903             /* An optional output reload might allow to delete INSN later.
3904                We mustn't make in-out reloads on insns that are not permitted
3905                output reloads.
3906                If this is an asm, we can't delete it; we must not even call
3907                push_reload for an optional output reload in this case,
3908                because we can't be sure that the constraint allows a register,
3909                and push_reload verifies the constraints for asms.  */
3910             && (modified[i] == RELOAD_READ
3911                 || (! no_output_reloads && ! this_insn_is_asm)))
3912           operand_reloadnum[i]
3913             = push_reload ((modified[i] != RELOAD_WRITE
3914                             ? recog_data.operand[i] : 0),
3915                            (modified[i] != RELOAD_READ
3916                             ? recog_data.operand[i] : 0),
3917                            (modified[i] != RELOAD_WRITE
3918                             ? recog_data.operand_loc[i] : 0),
3919                            (modified[i] != RELOAD_READ
3920                             ? recog_data.operand_loc[i] : 0),
3921                            (enum reg_class) goal_alternative[i],
3922                            (modified[i] == RELOAD_WRITE
3923                             ? VOIDmode : operand_mode[i]),
3924                            (modified[i] == RELOAD_READ
3925                             ? VOIDmode : operand_mode[i]),
3926                            (insn_code_number < 0 ? 0
3927                             : insn_data[insn_code_number].operand[i].strict_low),
3928                            1, i, operand_type[i]);
3929         /* If a memory reference remains (either as a MEM or a pseudo that
3930            did not get a hard register), yet we can't make an optional
3931            reload, check if this is actually a pseudo register reference;
3932            we then need to emit a USE and/or a CLOBBER so that reload
3933            inheritance will do the right thing.  */
3934         else if (replace
3935                  && (GET_CODE (operand) == MEM
3936                      || (GET_CODE (operand) == REG
3937                          && REGNO (operand) >= FIRST_PSEUDO_REGISTER
3938                          && reg_renumber [REGNO (operand)] < 0)))
3939           {
3940             operand = *recog_data.operand_loc[i];
3941
3942             while (GET_CODE (operand) == SUBREG)
3943               operand = SUBREG_REG (operand);
3944             if (GET_CODE (operand) == REG)
3945               {
3946                 if (modified[i] != RELOAD_WRITE)
3947                   /* We mark the USE with QImode so that we recognize
3948                      it as one that can be safely deleted at the end
3949                      of reload.  */
3950                   PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode, operand),
3951                                               insn), QImode);
3952                 if (modified[i] != RELOAD_READ)
3953                   emit_insn_after (gen_rtx_CLOBBER (VOIDmode, operand), insn);
3954               }
3955           }
3956       }
3957     else if (goal_alternative_matches[i] >= 0
3958              && goal_alternative_win[goal_alternative_matches[i]]
3959              && modified[i] == RELOAD_READ
3960              && modified[goal_alternative_matches[i]] == RELOAD_WRITE
3961              && ! no_input_reloads && ! no_output_reloads
3962              && optimize)
3963       {
3964         /* Similarly, make an optional reload for a pair of matching
3965            objects that are in MEM or a pseudo that didn't get a hard reg.  */
3966
3967         rtx operand = recog_data.operand[i];
3968
3969         while (GET_CODE (operand) == SUBREG)
3970           operand = SUBREG_REG (operand);
3971         if ((GET_CODE (operand) == MEM
3972              || (GET_CODE (operand) == REG
3973                  && REGNO (operand) >= FIRST_PSEUDO_REGISTER))
3974             && ((enum reg_class) goal_alternative[goal_alternative_matches[i]]
3975                 != NO_REGS))
3976           operand_reloadnum[i] = operand_reloadnum[goal_alternative_matches[i]]
3977             = push_reload (recog_data.operand[goal_alternative_matches[i]],
3978                            recog_data.operand[i],
3979                            recog_data.operand_loc[goal_alternative_matches[i]],
3980                            recog_data.operand_loc[i],
3981                            (enum reg_class) goal_alternative[goal_alternative_matches[i]],
3982                            operand_mode[goal_alternative_matches[i]],
3983                            operand_mode[i],
3984                            0, 1, goal_alternative_matches[i], RELOAD_OTHER);
3985       }
3986
3987   /* Perform whatever substitutions on the operands we are supposed
3988      to make due to commutativity or replacement of registers
3989      with equivalent constants or memory slots.  */
3990
3991   for (i = 0; i < noperands; i++)
3992     {
3993       /* We only do this on the last pass through reload, because it is
3994          possible for some data (like reg_equiv_address) to be changed during
3995          later passes.  Moreover, we loose the opportunity to get a useful
3996          reload_{in,out}_reg when we do these replacements.  */
3997
3998       if (replace)
3999         {
4000           rtx substitution = substed_operand[i];
4001
4002           *recog_data.operand_loc[i] = substitution;
4003
4004           /* If we're replacing an operand with a LABEL_REF, we need
4005              to make sure that there's a REG_LABEL note attached to
4006              this instruction.  */
4007           if (GET_CODE (insn) != JUMP_INSN
4008               && GET_CODE (substitution) == LABEL_REF
4009               && !find_reg_note (insn, REG_LABEL, XEXP (substitution, 0)))
4010             REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_LABEL,
4011                                                   XEXP (substitution, 0),
4012                                                   REG_NOTES (insn));
4013         }
4014       else
4015         retval |= (substed_operand[i] != *recog_data.operand_loc[i]);
4016     }
4017
4018   /* If this insn pattern contains any MATCH_DUP's, make sure that
4019      they will be substituted if the operands they match are substituted.
4020      Also do now any substitutions we already did on the operands.
4021
4022      Don't do this if we aren't making replacements because we might be
4023      propagating things allocated by frame pointer elimination into places
4024      it doesn't expect.  */
4025
4026   if (insn_code_number >= 0 && replace)
4027     for (i = insn_data[insn_code_number].n_dups - 1; i >= 0; i--)
4028       {
4029         int opno = recog_data.dup_num[i];
4030         *recog_data.dup_loc[i] = *recog_data.operand_loc[opno];
4031         dup_replacements (recog_data.dup_loc[i], recog_data.operand_loc[opno]);
4032       }
4033
4034 #if 0
4035   /* This loses because reloading of prior insns can invalidate the equivalence
4036      (or at least find_equiv_reg isn't smart enough to find it any more),
4037      causing this insn to need more reload regs than it needed before.
4038      It may be too late to make the reload regs available.
4039      Now this optimization is done safely in choose_reload_regs.  */
4040
4041   /* For each reload of a reg into some other class of reg,
4042      search for an existing equivalent reg (same value now) in the right class.
4043      We can use it as long as we don't need to change its contents.  */
4044   for (i = 0; i < n_reloads; i++)
4045     if (rld[i].reg_rtx == 0
4046         && rld[i].in != 0
4047         && GET_CODE (rld[i].in) == REG
4048         && rld[i].out == 0)
4049       {
4050         rld[i].reg_rtx
4051           = find_equiv_reg (rld[i].in, insn, rld[i].class, -1,
4052                             static_reload_reg_p, 0, rld[i].inmode);
4053         /* Prevent generation of insn to load the value
4054            because the one we found already has the value.  */
4055         if (rld[i].reg_rtx)
4056           rld[i].in = rld[i].reg_rtx;
4057       }
4058 #endif
4059
4060   /* Perhaps an output reload can be combined with another
4061      to reduce needs by one.  */
4062   if (!goal_earlyclobber)
4063     combine_reloads ();
4064
4065   /* If we have a pair of reloads for parts of an address, they are reloading
4066      the same object, the operands themselves were not reloaded, and they
4067      are for two operands that are supposed to match, merge the reloads and
4068      change the type of the surviving reload to RELOAD_FOR_OPERAND_ADDRESS.  */
4069
4070   for (i = 0; i < n_reloads; i++)
4071     {
4072       int k;
4073
4074       for (j = i + 1; j < n_reloads; j++)
4075         if ((rld[i].when_needed == RELOAD_FOR_INPUT_ADDRESS
4076              || rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS
4077              || rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS
4078              || rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
4079             && (rld[j].when_needed == RELOAD_FOR_INPUT_ADDRESS
4080                 || rld[j].when_needed == RELOAD_FOR_OUTPUT_ADDRESS
4081                 || rld[j].when_needed == RELOAD_FOR_INPADDR_ADDRESS
4082                 || rld[j].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
4083             && rtx_equal_p (rld[i].in, rld[j].in)
4084             && (operand_reloadnum[rld[i].opnum] < 0
4085                 || rld[operand_reloadnum[rld[i].opnum]].optional)
4086             && (operand_reloadnum[rld[j].opnum] < 0
4087                 || rld[operand_reloadnum[rld[j].opnum]].optional)
4088             && (goal_alternative_matches[rld[i].opnum] == rld[j].opnum
4089                 || (goal_alternative_matches[rld[j].opnum]
4090                     == rld[i].opnum)))
4091           {
4092             for (k = 0; k < n_replacements; k++)
4093               if (replacements[k].what == j)
4094                 replacements[k].what = i;
4095
4096             if (rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS
4097                 || rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
4098               rld[i].when_needed = RELOAD_FOR_OPADDR_ADDR;
4099             else
4100               rld[i].when_needed = RELOAD_FOR_OPERAND_ADDRESS;
4101             rld[j].in = 0;
4102           }
4103     }
4104
4105   /* Scan all the reloads and update their type.
4106      If a reload is for the address of an operand and we didn't reload
4107      that operand, change the type.  Similarly, change the operand number
4108      of a reload when two operands match.  If a reload is optional, treat it
4109      as though the operand isn't reloaded.
4110
4111      ??? This latter case is somewhat odd because if we do the optional
4112      reload, it means the object is hanging around.  Thus we need only
4113      do the address reload if the optional reload was NOT done.
4114
4115      Change secondary reloads to be the address type of their operand, not
4116      the normal type.
4117
4118      If an operand's reload is now RELOAD_OTHER, change any
4119      RELOAD_FOR_INPUT_ADDRESS reloads of that operand to
4120      RELOAD_FOR_OTHER_ADDRESS.  */
4121
4122   for (i = 0; i < n_reloads; i++)
4123     {
4124       if (rld[i].secondary_p
4125           && rld[i].when_needed == operand_type[rld[i].opnum])
4126         rld[i].when_needed = address_type[rld[i].opnum];
4127
4128       if ((rld[i].when_needed == RELOAD_FOR_INPUT_ADDRESS
4129            || rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS
4130            || rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS
4131            || rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
4132           && (operand_reloadnum[rld[i].opnum] < 0
4133               || rld[operand_reloadnum[rld[i].opnum]].optional))
4134         {
4135           /* If we have a secondary reload to go along with this reload,
4136              change its type to RELOAD_FOR_OPADDR_ADDR.  */
4137
4138           if ((rld[i].when_needed == RELOAD_FOR_INPUT_ADDRESS
4139                || rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS)
4140               && rld[i].secondary_in_reload != -1)
4141             {
4142               int secondary_in_reload = rld[i].secondary_in_reload;
4143
4144               rld[secondary_in_reload].when_needed = RELOAD_FOR_OPADDR_ADDR;
4145
4146               /* If there's a tertiary reload we have to change it also.  */
4147               if (secondary_in_reload > 0
4148                   && rld[secondary_in_reload].secondary_in_reload != -1)
4149                 rld[rld[secondary_in_reload].secondary_in_reload].when_needed
4150                   = RELOAD_FOR_OPADDR_ADDR;
4151             }
4152
4153           if ((rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS
4154                || rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
4155               && rld[i].secondary_out_reload != -1)
4156             {
4157               int secondary_out_reload = rld[i].secondary_out_reload;
4158
4159               rld[secondary_out_reload].when_needed = RELOAD_FOR_OPADDR_ADDR;
4160
4161               /* If there's a tertiary reload we have to change it also.  */
4162               if (secondary_out_reload
4163                   && rld[secondary_out_reload].secondary_out_reload != -1)
4164                 rld[rld[secondary_out_reload].secondary_out_reload].when_needed
4165                   = RELOAD_FOR_OPADDR_ADDR;
4166             }
4167
4168           if (rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS
4169               || rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
4170             rld[i].when_needed = RELOAD_FOR_OPADDR_ADDR;
4171           else
4172             rld[i].when_needed = RELOAD_FOR_OPERAND_ADDRESS;
4173         }
4174
4175       if ((rld[i].when_needed == RELOAD_FOR_INPUT_ADDRESS
4176            || rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS)
4177           && operand_reloadnum[rld[i].opnum] >= 0
4178           && (rld[operand_reloadnum[rld[i].opnum]].when_needed
4179               == RELOAD_OTHER))
4180         rld[i].when_needed = RELOAD_FOR_OTHER_ADDRESS;
4181
4182       if (goal_alternative_matches[rld[i].opnum] >= 0)
4183         rld[i].opnum = goal_alternative_matches[rld[i].opnum];
4184     }
4185
4186   /* Scan all the reloads, and check for RELOAD_FOR_OPERAND_ADDRESS reloads.
4187      If we have more than one, then convert all RELOAD_FOR_OPADDR_ADDR
4188      reloads to RELOAD_FOR_OPERAND_ADDRESS reloads.
4189
4190      choose_reload_regs assumes that RELOAD_FOR_OPADDR_ADDR reloads never
4191      conflict with RELOAD_FOR_OPERAND_ADDRESS reloads.  This is true for a
4192      single pair of RELOAD_FOR_OPADDR_ADDR/RELOAD_FOR_OPERAND_ADDRESS reloads.
4193      However, if there is more than one RELOAD_FOR_OPERAND_ADDRESS reload,
4194      then a RELOAD_FOR_OPADDR_ADDR reload conflicts with all
4195      RELOAD_FOR_OPERAND_ADDRESS reloads other than the one that uses it.
4196      This is complicated by the fact that a single operand can have more
4197      than one RELOAD_FOR_OPERAND_ADDRESS reload.  It is very difficult to fix
4198      choose_reload_regs without affecting code quality, and cases that
4199      actually fail are extremely rare, so it turns out to be better to fix
4200      the problem here by not generating cases that choose_reload_regs will
4201      fail for.  */
4202   /* There is a similar problem with RELOAD_FOR_INPUT_ADDRESS /
4203      RELOAD_FOR_OUTPUT_ADDRESS when there is more than one of a kind for
4204      a single operand.
4205      We can reduce the register pressure by exploiting that a
4206      RELOAD_FOR_X_ADDR_ADDR that precedes all RELOAD_FOR_X_ADDRESS reloads
4207      does not conflict with any of them, if it is only used for the first of
4208      the RELOAD_FOR_X_ADDRESS reloads.  */
4209   {
4210     int first_op_addr_num = -2;
4211     int first_inpaddr_num[MAX_RECOG_OPERANDS];
4212     int first_outpaddr_num[MAX_RECOG_OPERANDS];
4213     int need_change = 0;
4214     /* We use last_op_addr_reload and the contents of the above arrays
4215        first as flags - -2 means no instance encountered, -1 means exactly
4216        one instance encountered.
4217        If more than one instance has been encountered, we store the reload
4218        number of the first reload of the kind in question; reload numbers
4219        are known to be non-negative.  */
4220     for (i = 0; i < noperands; i++)
4221       first_inpaddr_num[i] = first_outpaddr_num[i] = -2;
4222     for (i = n_reloads - 1; i >= 0; i--)
4223       {
4224         switch (rld[i].when_needed)
4225           {
4226           case RELOAD_FOR_OPERAND_ADDRESS:
4227             if (++first_op_addr_num >= 0)
4228               {
4229                 first_op_addr_num = i;
4230                 need_change = 1;
4231               }
4232             break;
4233           case RELOAD_FOR_INPUT_ADDRESS:
4234             if (++first_inpaddr_num[rld[i].opnum] >= 0)
4235               {
4236                 first_inpaddr_num[rld[i].opnum] = i;
4237                 need_change = 1;
4238               }
4239             break;
4240           case RELOAD_FOR_OUTPUT_ADDRESS:
4241             if (++first_outpaddr_num[rld[i].opnum] >= 0)
4242               {
4243                 first_outpaddr_num[rld[i].opnum] = i;
4244                 need_change = 1;
4245               }
4246             break;
4247           default:
4248             break;
4249           }
4250       }
4251
4252     if (need_change)
4253       {
4254         for (i = 0; i < n_reloads; i++)
4255           {
4256             int first_num;
4257             enum reload_type type;
4258
4259             switch (rld[i].when_needed)
4260               {
4261               case RELOAD_FOR_OPADDR_ADDR:
4262                 first_num = first_op_addr_num;
4263                 type = RELOAD_FOR_OPERAND_ADDRESS;
4264                 break;
4265               case RELOAD_FOR_INPADDR_ADDRESS:
4266                 first_num = first_inpaddr_num[rld[i].opnum];
4267                 type = RELOAD_FOR_INPUT_ADDRESS;
4268                 break;
4269               case RELOAD_FOR_OUTADDR_ADDRESS:
4270                 first_num = first_outpaddr_num[rld[i].opnum];
4271                 type = RELOAD_FOR_OUTPUT_ADDRESS;
4272                 break;
4273               default:
4274                 continue;
4275               }
4276             if (first_num < 0)
4277               continue;
4278             else if (i > first_num)
4279               rld[i].when_needed = type;
4280             else
4281               {
4282                 /* Check if the only TYPE reload that uses reload I is
4283                    reload FIRST_NUM.  */
4284                 for (j = n_reloads - 1; j > first_num; j--)
4285                   {
4286                     if (rld[j].when_needed == type
4287                         && (rld[i].secondary_p
4288                             ? rld[j].secondary_in_reload == i
4289                             : reg_mentioned_p (rld[i].in, rld[j].in)))
4290                       {
4291                         rld[i].when_needed = type;
4292                         break;
4293                       }
4294                   }
4295               }
4296           }
4297       }
4298   }
4299
4300   /* See if we have any reloads that are now allowed to be merged
4301      because we've changed when the reload is needed to
4302      RELOAD_FOR_OPERAND_ADDRESS or RELOAD_FOR_OTHER_ADDRESS.  Only
4303      check for the most common cases.  */
4304
4305   for (i = 0; i < n_reloads; i++)
4306     if (rld[i].in != 0 && rld[i].out == 0
4307         && (rld[i].when_needed == RELOAD_FOR_OPERAND_ADDRESS
4308             || rld[i].when_needed == RELOAD_FOR_OPADDR_ADDR
4309             || rld[i].when_needed == RELOAD_FOR_OTHER_ADDRESS))
4310       for (j = 0; j < n_reloads; j++)
4311         if (i != j && rld[j].in != 0 && rld[j].out == 0
4312             && rld[j].when_needed == rld[i].when_needed
4313             && MATCHES (rld[i].in, rld[j].in)
4314             && rld[i].class == rld[j].class
4315             && !rld[i].nocombine && !rld[j].nocombine
4316             && rld[i].reg_rtx == rld[j].reg_rtx)
4317           {
4318             rld[i].opnum = MIN (rld[i].opnum, rld[j].opnum);
4319             transfer_replacements (i, j);
4320             rld[j].in = 0;
4321           }
4322
4323 #ifdef HAVE_cc0
4324   /* If we made any reloads for addresses, see if they violate a
4325      "no input reloads" requirement for this insn.  But loads that we
4326      do after the insn (such as for output addresses) are fine.  */
4327   if (no_input_reloads)
4328     for (i = 0; i < n_reloads; i++)
4329       if (rld[i].in != 0
4330           && rld[i].when_needed != RELOAD_FOR_OUTADDR_ADDRESS
4331           && rld[i].when_needed != RELOAD_FOR_OUTPUT_ADDRESS)
4332         abort ();
4333 #endif
4334
4335   /* Compute reload_mode and reload_nregs.  */
4336   for (i = 0; i < n_reloads; i++)
4337     {
4338       rld[i].mode
4339         = (rld[i].inmode == VOIDmode
4340            || (GET_MODE_SIZE (rld[i].outmode)
4341                > GET_MODE_SIZE (rld[i].inmode)))
4342           ? rld[i].outmode : rld[i].inmode;
4343
4344       rld[i].nregs = CLASS_MAX_NREGS (rld[i].class, rld[i].mode);
4345     }
4346
4347   /* Special case a simple move with an input reload and a
4348      destination of a hard reg, if the hard reg is ok, use it.  */
4349   for (i = 0; i < n_reloads; i++)
4350     if (rld[i].when_needed == RELOAD_FOR_INPUT
4351         && GET_CODE (PATTERN (insn)) == SET
4352         && GET_CODE (SET_DEST (PATTERN (insn))) == REG
4353         && SET_SRC (PATTERN (insn)) == rld[i].in)
4354       {
4355         rtx dest = SET_DEST (PATTERN (insn));
4356         unsigned int regno = REGNO (dest);
4357
4358         if (regno < FIRST_PSEUDO_REGISTER
4359             && TEST_HARD_REG_BIT (reg_class_contents[rld[i].class], regno)
4360             && HARD_REGNO_MODE_OK (regno, rld[i].mode))
4361           rld[i].reg_rtx = dest;
4362       }
4363
4364   return retval;
4365 }
4366
4367 /* Return 1 if alternative number ALTNUM in constraint-string CONSTRAINT
4368    accepts a memory operand with constant address.  */
4369
4370 static int
4371 alternative_allows_memconst (constraint, altnum)
4372      const char *constraint;
4373      int altnum;
4374 {
4375   int c;
4376   /* Skip alternatives before the one requested.  */
4377   while (altnum > 0)
4378     {
4379       while (*constraint++ != ',');
4380       altnum--;
4381     }
4382   /* Scan the requested alternative for 'm' or 'o'.
4383      If one of them is present, this alternative accepts memory constants.  */
4384   for (; (c = *constraint) && c != ',' && c != '#';
4385        constraint += CONSTRAINT_LEN (c, constraint))
4386     if (c == 'm' || c == 'o' || EXTRA_MEMORY_CONSTRAINT (c, constraint))
4387       return 1;
4388   return 0;
4389 }
4390 \f
4391 /* Scan X for memory references and scan the addresses for reloading.
4392    Also checks for references to "constant" regs that we want to eliminate
4393    and replaces them with the values they stand for.
4394    We may alter X destructively if it contains a reference to such.
4395    If X is just a constant reg, we return the equivalent value
4396    instead of X.
4397
4398    IND_LEVELS says how many levels of indirect addressing this machine
4399    supports.
4400
4401    OPNUM and TYPE identify the purpose of the reload.
4402
4403    IS_SET_DEST is true if X is the destination of a SET, which is not
4404    appropriate to be replaced by a constant.
4405
4406    INSN, if nonzero, is the insn in which we do the reload.  It is used
4407    to determine if we may generate output reloads, and where to put USEs
4408    for pseudos that we have to replace with stack slots.
4409
4410    ADDRESS_RELOADED.  If nonzero, is a pointer to where we put the
4411    result of find_reloads_address.  */
4412
4413 static rtx
4414 find_reloads_toplev (x, opnum, type, ind_levels, is_set_dest, insn,
4415                      address_reloaded)
4416      rtx x;
4417      int opnum;
4418      enum reload_type type;
4419      int ind_levels;
4420      int is_set_dest;
4421      rtx insn;
4422      int *address_reloaded;
4423 {
4424   RTX_CODE code = GET_CODE (x);
4425
4426   const char *fmt = GET_RTX_FORMAT (code);
4427   int i;
4428   int copied;
4429
4430   if (code == REG)
4431     {
4432       /* This code is duplicated for speed in find_reloads.  */
4433       int regno = REGNO (x);
4434       if (reg_equiv_constant[regno] != 0 && !is_set_dest)
4435         x = reg_equiv_constant[regno];
4436 #if 0
4437       /*  This creates (subreg (mem...)) which would cause an unnecessary
4438           reload of the mem.  */
4439       else if (reg_equiv_mem[regno] != 0)
4440         x = reg_equiv_mem[regno];
4441 #endif
4442       else if (reg_equiv_memory_loc[regno]
4443                && (reg_equiv_address[regno] != 0 || num_not_at_initial_offset))
4444         {
4445           rtx mem = make_memloc (x, regno);
4446           if (reg_equiv_address[regno]
4447               || ! rtx_equal_p (mem, reg_equiv_mem[regno]))
4448             {
4449               /* If this is not a toplevel operand, find_reloads doesn't see
4450                  this substitution.  We have to emit a USE of the pseudo so
4451                  that delete_output_reload can see it.  */
4452               if (replace_reloads && recog_data.operand[opnum] != x)
4453                 /* We mark the USE with QImode so that we recognize it
4454                    as one that can be safely deleted at the end of
4455                    reload.  */
4456                 PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode, x), insn),
4457                           QImode);
4458               x = mem;
4459               i = find_reloads_address (GET_MODE (x), &x, XEXP (x, 0), &XEXP (x, 0),
4460                                         opnum, type, ind_levels, insn);
4461               if (address_reloaded)
4462                 *address_reloaded = i;
4463             }
4464         }
4465       return x;
4466     }
4467   if (code == MEM)
4468     {
4469       rtx tem = x;
4470
4471       i = find_reloads_address (GET_MODE (x), &tem, XEXP (x, 0), &XEXP (x, 0),
4472                                 opnum, type, ind_levels, insn);
4473       if (address_reloaded)
4474         *address_reloaded = i;
4475
4476       return tem;
4477     }
4478
4479   if (code == SUBREG && GET_CODE (SUBREG_REG (x)) == REG)
4480     {
4481       /* Check for SUBREG containing a REG that's equivalent to a constant.
4482          If the constant has a known value, truncate it right now.
4483          Similarly if we are extracting a single-word of a multi-word
4484          constant.  If the constant is symbolic, allow it to be substituted
4485          normally.  push_reload will strip the subreg later.  If the
4486          constant is VOIDmode, abort because we will lose the mode of
4487          the register (this should never happen because one of the cases
4488          above should handle it).  */
4489
4490       int regno = REGNO (SUBREG_REG (x));
4491       rtx tem;
4492
4493       if (subreg_lowpart_p (x)
4494           && regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
4495           && reg_equiv_constant[regno] != 0
4496           && (tem = gen_lowpart_common (GET_MODE (x),
4497                                         reg_equiv_constant[regno])) != 0)
4498         return tem;
4499
4500       if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
4501           && reg_equiv_constant[regno] != 0)
4502         {
4503           tem =
4504             simplify_gen_subreg (GET_MODE (x), reg_equiv_constant[regno],
4505                                  GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
4506           if (!tem)
4507             abort ();
4508           return tem;
4509         }
4510
4511       /* If the subreg contains a reg that will be converted to a mem,
4512          convert the subreg to a narrower memref now.
4513          Otherwise, we would get (subreg (mem ...) ...),
4514          which would force reload of the mem.
4515
4516          We also need to do this if there is an equivalent MEM that is
4517          not offsettable.  In that case, alter_subreg would produce an
4518          invalid address on big-endian machines.
4519
4520          For machines that extend byte loads, we must not reload using
4521          a wider mode if we have a paradoxical SUBREG.  find_reloads will
4522          force a reload in that case.  So we should not do anything here.  */
4523
4524       else if (regno >= FIRST_PSEUDO_REGISTER
4525 #ifdef LOAD_EXTEND_OP
4526                && (GET_MODE_SIZE (GET_MODE (x))
4527                    <= GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
4528 #endif
4529                && (reg_equiv_address[regno] != 0
4530                    || (reg_equiv_mem[regno] != 0
4531                        && (! strict_memory_address_p (GET_MODE (x),
4532                                                       XEXP (reg_equiv_mem[regno], 0))
4533                            || ! offsettable_memref_p (reg_equiv_mem[regno])
4534                            || num_not_at_initial_offset))))
4535         x = find_reloads_subreg_address (x, 1, opnum, type, ind_levels,
4536                                          insn);
4537     }
4538
4539   for (copied = 0, i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
4540     {
4541       if (fmt[i] == 'e')
4542         {
4543           rtx new_part = find_reloads_toplev (XEXP (x, i), opnum, type,
4544                                               ind_levels, is_set_dest, insn,
4545                                               address_reloaded);
4546           /* If we have replaced a reg with it's equivalent memory loc -
4547              that can still be handled here e.g. if it's in a paradoxical
4548              subreg - we must make the change in a copy, rather than using
4549              a destructive change.  This way, find_reloads can still elect
4550              not to do the change.  */
4551           if (new_part != XEXP (x, i) && ! CONSTANT_P (new_part) && ! copied)
4552             {
4553               x = shallow_copy_rtx (x);
4554               copied = 1;
4555             }
4556           XEXP (x, i) = new_part;
4557         }
4558     }
4559   return x;
4560 }
4561
4562 /* Return a mem ref for the memory equivalent of reg REGNO.
4563    This mem ref is not shared with anything.  */
4564
4565 static rtx
4566 make_memloc (ad, regno)
4567      rtx ad;
4568      int regno;
4569 {
4570   /* We must rerun eliminate_regs, in case the elimination
4571      offsets have changed.  */
4572   rtx tem
4573     = XEXP (eliminate_regs (reg_equiv_memory_loc[regno], 0, NULL_RTX), 0);
4574
4575   /* If TEM might contain a pseudo, we must copy it to avoid
4576      modifying it when we do the substitution for the reload.  */
4577   if (rtx_varies_p (tem, 0))
4578     tem = copy_rtx (tem);
4579
4580   tem = replace_equiv_address_nv (reg_equiv_memory_loc[regno], tem);
4581   tem = adjust_address_nv (tem, GET_MODE (ad), 0);
4582
4583   /* Copy the result if it's still the same as the equivalence, to avoid
4584      modifying it when we do the substitution for the reload.  */
4585   if (tem == reg_equiv_memory_loc[regno])
4586     tem = copy_rtx (tem);
4587   return tem;
4588 }
4589
4590 /* Record all reloads needed for handling memory address AD
4591    which appears in *LOC in a memory reference to mode MODE
4592    which itself is found in location  *MEMREFLOC.
4593    Note that we take shortcuts assuming that no multi-reg machine mode
4594    occurs as part of an address.
4595
4596    OPNUM and TYPE specify the purpose of this reload.
4597
4598    IND_LEVELS says how many levels of indirect addressing this machine
4599    supports.
4600
4601    INSN, if nonzero, is the insn in which we do the reload.  It is used
4602    to determine if we may generate output reloads, and where to put USEs
4603    for pseudos that we have to replace with stack slots.
4604
4605    Value is nonzero if this address is reloaded or replaced as a whole.
4606    This is interesting to the caller if the address is an autoincrement.
4607
4608    Note that there is no verification that the address will be valid after
4609    this routine does its work.  Instead, we rely on the fact that the address
4610    was valid when reload started.  So we need only undo things that reload
4611    could have broken.  These are wrong register types, pseudos not allocated
4612    to a hard register, and frame pointer elimination.  */
4613
4614 static int
4615 find_reloads_address (mode, memrefloc, ad, loc, opnum, type, ind_levels, insn)
4616      enum machine_mode mode;
4617      rtx *memrefloc;
4618      rtx ad;
4619      rtx *loc;
4620      int opnum;
4621      enum reload_type type;
4622      int ind_levels;
4623      rtx insn;
4624 {
4625   int regno;
4626   int removed_and = 0;
4627   rtx tem;
4628
4629   /* If the address is a register, see if it is a legitimate address and
4630      reload if not.  We first handle the cases where we need not reload
4631      or where we must reload in a non-standard way.  */
4632
4633   if (GET_CODE (ad) == REG)
4634     {
4635       regno = REGNO (ad);
4636
4637       /* If the register is equivalent to an invariant expression, substitute
4638          the invariant, and eliminate any eliminable register references.  */
4639       tem = reg_equiv_constant[regno];
4640       if (tem != 0
4641           && (tem = eliminate_regs (tem, mode, insn))
4642           && strict_memory_address_p (mode, tem))
4643         {
4644           *loc = ad = tem;
4645           return 0;
4646         }
4647
4648       tem = reg_equiv_memory_loc[regno];
4649       if (tem != 0)
4650         {
4651           if (reg_equiv_address[regno] != 0 || num_not_at_initial_offset)
4652             {
4653               tem = make_memloc (ad, regno);
4654               if (! strict_memory_address_p (GET_MODE (tem), XEXP (tem, 0)))
4655                 {
4656                   find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
4657                                         &XEXP (tem, 0), opnum,
4658                                         ADDR_TYPE (type), ind_levels, insn);
4659                 }
4660               /* We can avoid a reload if the register's equivalent memory
4661                  expression is valid as an indirect memory address.
4662                  But not all addresses are valid in a mem used as an indirect
4663                  address: only reg or reg+constant.  */
4664
4665               if (ind_levels > 0
4666                   && strict_memory_address_p (mode, tem)
4667                   && (GET_CODE (XEXP (tem, 0)) == REG
4668                       || (GET_CODE (XEXP (tem, 0)) == PLUS
4669                           && GET_CODE (XEXP (XEXP (tem, 0), 0)) == REG
4670                           && CONSTANT_P (XEXP (XEXP (tem, 0), 1)))))
4671                 {
4672                   /* TEM is not the same as what we'll be replacing the
4673                      pseudo with after reload, put a USE in front of INSN
4674                      in the final reload pass.  */
4675                   if (replace_reloads
4676                       && num_not_at_initial_offset
4677                       && ! rtx_equal_p (tem, reg_equiv_mem[regno]))
4678                     {
4679                       *loc = tem;
4680                       /* We mark the USE with QImode so that we
4681                          recognize it as one that can be safely
4682                          deleted at the end of reload.  */
4683                       PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode, ad),
4684                                                   insn), QImode);
4685
4686                       /* This doesn't really count as replacing the address
4687                          as a whole, since it is still a memory access.  */
4688                     }
4689                   return 0;
4690                 }
4691               ad = tem;
4692             }
4693         }
4694
4695       /* The only remaining case where we can avoid a reload is if this is a
4696          hard register that is valid as a base register and which is not the
4697          subject of a CLOBBER in this insn.  */
4698
4699       else if (regno < FIRST_PSEUDO_REGISTER
4700                && REGNO_MODE_OK_FOR_BASE_P (regno, mode)
4701                && ! regno_clobbered_p (regno, this_insn, mode, 0))
4702         return 0;
4703
4704       /* If we do not have one of the cases above, we must do the reload.  */
4705       push_reload (ad, NULL_RTX, loc, (rtx*) 0, MODE_BASE_REG_CLASS (mode),
4706                    GET_MODE (ad), VOIDmode, 0, 0, opnum, type);
4707       return 1;
4708     }
4709
4710   if (strict_memory_address_p (mode, ad))
4711     {
4712       /* The address appears valid, so reloads are not needed.
4713          But the address may contain an eliminable register.
4714          This can happen because a machine with indirect addressing
4715          may consider a pseudo register by itself a valid address even when
4716          it has failed to get a hard reg.
4717          So do a tree-walk to find and eliminate all such regs.  */
4718
4719       /* But first quickly dispose of a common case.  */
4720       if (GET_CODE (ad) == PLUS
4721           && GET_CODE (XEXP (ad, 1)) == CONST_INT
4722           && GET_CODE (XEXP (ad, 0)) == REG
4723           && reg_equiv_constant[REGNO (XEXP (ad, 0))] == 0)
4724         return 0;
4725
4726       subst_reg_equivs_changed = 0;
4727       *loc = subst_reg_equivs (ad, insn);
4728
4729       if (! subst_reg_equivs_changed)
4730         return 0;
4731
4732       /* Check result for validity after substitution.  */
4733       if (strict_memory_address_p (mode, ad))
4734         return 0;
4735     }
4736
4737 #ifdef LEGITIMIZE_RELOAD_ADDRESS
4738   do
4739     {
4740       if (memrefloc)
4741         {
4742           LEGITIMIZE_RELOAD_ADDRESS (ad, GET_MODE (*memrefloc), opnum, type,
4743                                      ind_levels, win);
4744         }
4745       break;
4746     win:
4747       *memrefloc = copy_rtx (*memrefloc);
4748       XEXP (*memrefloc, 0) = ad;
4749       move_replacements (&ad, &XEXP (*memrefloc, 0));
4750       return 1;
4751     }
4752   while (0);
4753 #endif
4754
4755   /* The address is not valid.  We have to figure out why.  First see if
4756      we have an outer AND and remove it if so.  Then analyze what's inside.  */
4757
4758   if (GET_CODE (ad) == AND)
4759     {
4760       removed_and = 1;
4761       loc = &XEXP (ad, 0);
4762       ad = *loc;
4763     }
4764
4765   /* One possibility for why the address is invalid is that it is itself
4766      a MEM.  This can happen when the frame pointer is being eliminated, a
4767      pseudo is not allocated to a hard register, and the offset between the
4768      frame and stack pointers is not its initial value.  In that case the
4769      pseudo will have been replaced by a MEM referring to the
4770      stack pointer.  */
4771   if (GET_CODE (ad) == MEM)
4772     {
4773       /* First ensure that the address in this MEM is valid.  Then, unless
4774          indirect addresses are valid, reload the MEM into a register.  */
4775       tem = ad;
4776       find_reloads_address (GET_MODE (ad), &tem, XEXP (ad, 0), &XEXP (ad, 0),
4777                             opnum, ADDR_TYPE (type),
4778                             ind_levels == 0 ? 0 : ind_levels - 1, insn);
4779
4780       /* If tem was changed, then we must create a new memory reference to
4781          hold it and store it back into memrefloc.  */
4782       if (tem != ad && memrefloc)
4783         {
4784           *memrefloc = copy_rtx (*memrefloc);
4785           copy_replacements (tem, XEXP (*memrefloc, 0));
4786           loc = &XEXP (*memrefloc, 0);
4787           if (removed_and)
4788             loc = &XEXP (*loc, 0);
4789         }
4790
4791       /* Check similar cases as for indirect addresses as above except
4792          that we can allow pseudos and a MEM since they should have been
4793          taken care of above.  */
4794
4795       if (ind_levels == 0
4796           || (GET_CODE (XEXP (tem, 0)) == SYMBOL_REF && ! indirect_symref_ok)
4797           || GET_CODE (XEXP (tem, 0)) == MEM
4798           || ! (GET_CODE (XEXP (tem, 0)) == REG
4799                 || (GET_CODE (XEXP (tem, 0)) == PLUS
4800                     && GET_CODE (XEXP (XEXP (tem, 0), 0)) == REG
4801                     && GET_CODE (XEXP (XEXP (tem, 0), 1)) == CONST_INT)))
4802         {
4803           /* Must use TEM here, not AD, since it is the one that will
4804              have any subexpressions reloaded, if needed.  */
4805           push_reload (tem, NULL_RTX, loc, (rtx*) 0,
4806                        MODE_BASE_REG_CLASS (mode), GET_MODE (tem),
4807                        VOIDmode, 0,
4808                        0, opnum, type);
4809           return ! removed_and;
4810         }
4811       else
4812         return 0;
4813     }
4814
4815   /* If we have address of a stack slot but it's not valid because the
4816      displacement is too large, compute the sum in a register.
4817      Handle all base registers here, not just fp/ap/sp, because on some
4818      targets (namely SH) we can also get too large displacements from
4819      big-endian corrections.  */
4820   else if (GET_CODE (ad) == PLUS
4821            && GET_CODE (XEXP (ad, 0)) == REG
4822            && REGNO (XEXP (ad, 0)) < FIRST_PSEUDO_REGISTER
4823            && REG_MODE_OK_FOR_BASE_P (XEXP (ad, 0), mode)
4824            && GET_CODE (XEXP (ad, 1)) == CONST_INT)
4825     {
4826       /* Unshare the MEM rtx so we can safely alter it.  */
4827       if (memrefloc)
4828         {
4829           *memrefloc = copy_rtx (*memrefloc);
4830           loc = &XEXP (*memrefloc, 0);
4831           if (removed_and)
4832             loc = &XEXP (*loc, 0);
4833         }
4834
4835       if (double_reg_address_ok)
4836         {
4837           /* Unshare the sum as well.  */
4838           *loc = ad = copy_rtx (ad);
4839
4840           /* Reload the displacement into an index reg.
4841              We assume the frame pointer or arg pointer is a base reg.  */
4842           find_reloads_address_part (XEXP (ad, 1), &XEXP (ad, 1),
4843                                      INDEX_REG_CLASS, GET_MODE (ad), opnum,
4844                                      type, ind_levels);
4845           return 0;
4846         }
4847       else
4848         {
4849           /* If the sum of two regs is not necessarily valid,
4850              reload the sum into a base reg.
4851              That will at least work.  */
4852           find_reloads_address_part (ad, loc, MODE_BASE_REG_CLASS (mode),
4853                                      Pmode, opnum, type, ind_levels);
4854         }
4855       return ! removed_and;
4856     }
4857
4858   /* If we have an indexed stack slot, there are three possible reasons why
4859      it might be invalid: The index might need to be reloaded, the address
4860      might have been made by frame pointer elimination and hence have a
4861      constant out of range, or both reasons might apply.
4862
4863      We can easily check for an index needing reload, but even if that is the
4864      case, we might also have an invalid constant.  To avoid making the
4865      conservative assumption and requiring two reloads, we see if this address
4866      is valid when not interpreted strictly.  If it is, the only problem is
4867      that the index needs a reload and find_reloads_address_1 will take care
4868      of it.
4869
4870      If we decide to do something here, it must be that
4871      `double_reg_address_ok' is true and that this address rtl was made by
4872      eliminate_regs.  We generate a reload of the fp/sp/ap + constant and
4873      rework the sum so that the reload register will be added to the index.
4874      This is safe because we know the address isn't shared.
4875
4876      We check for fp/ap/sp as both the first and second operand of the
4877      innermost PLUS.  */
4878
4879   else if (GET_CODE (ad) == PLUS && GET_CODE (XEXP (ad, 1)) == CONST_INT
4880            && GET_CODE (XEXP (ad, 0)) == PLUS
4881            && (XEXP (XEXP (ad, 0), 0) == frame_pointer_rtx
4882 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
4883                || XEXP (XEXP (ad, 0), 0) == hard_frame_pointer_rtx
4884 #endif
4885 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
4886                || XEXP (XEXP (ad, 0), 0) == arg_pointer_rtx
4887 #endif
4888                || XEXP (XEXP (ad, 0), 0) == stack_pointer_rtx)
4889            && ! memory_address_p (mode, ad))
4890     {
4891       *loc = ad = gen_rtx_PLUS (GET_MODE (ad),
4892                                 plus_constant (XEXP (XEXP (ad, 0), 0),
4893                                                INTVAL (XEXP (ad, 1))),
4894                                 XEXP (XEXP (ad, 0), 1));
4895       find_reloads_address_part (XEXP (ad, 0), &XEXP (ad, 0),
4896                                  MODE_BASE_REG_CLASS (mode),
4897                                  GET_MODE (ad), opnum, type, ind_levels);
4898       find_reloads_address_1 (mode, XEXP (ad, 1), 1, &XEXP (ad, 1), opnum,
4899                               type, 0, insn);
4900
4901       return 0;
4902     }
4903
4904   else if (GET_CODE (ad) == PLUS && GET_CODE (XEXP (ad, 1)) == CONST_INT
4905            && GET_CODE (XEXP (ad, 0)) == PLUS
4906            && (XEXP (XEXP (ad, 0), 1) == frame_pointer_rtx
4907 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
4908                || XEXP (XEXP (ad, 0), 1) == hard_frame_pointer_rtx
4909 #endif
4910 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
4911                || XEXP (XEXP (ad, 0), 1) == arg_pointer_rtx
4912 #endif
4913                || XEXP (XEXP (ad, 0), 1) == stack_pointer_rtx)
4914            && ! memory_address_p (mode, ad))
4915     {
4916       *loc = ad = gen_rtx_PLUS (GET_MODE (ad),
4917                                 XEXP (XEXP (ad, 0), 0),
4918                                 plus_constant (XEXP (XEXP (ad, 0), 1),
4919                                                INTVAL (XEXP (ad, 1))));
4920       find_reloads_address_part (XEXP (ad, 1), &XEXP (ad, 1),
4921                                  MODE_BASE_REG_CLASS (mode),
4922                                  GET_MODE (ad), opnum, type, ind_levels);
4923       find_reloads_address_1 (mode, XEXP (ad, 0), 1, &XEXP (ad, 0), opnum,
4924                               type, 0, insn);
4925
4926       return 0;
4927     }
4928
4929   /* See if address becomes valid when an eliminable register
4930      in a sum is replaced.  */
4931
4932   tem = ad;
4933   if (GET_CODE (ad) == PLUS)
4934     tem = subst_indexed_address (ad);
4935   if (tem != ad && strict_memory_address_p (mode, tem))
4936     {
4937       /* Ok, we win that way.  Replace any additional eliminable
4938          registers.  */
4939
4940       subst_reg_equivs_changed = 0;
4941       tem = subst_reg_equivs (tem, insn);
4942
4943       /* Make sure that didn't make the address invalid again.  */
4944
4945       if (! subst_reg_equivs_changed || strict_memory_address_p (mode, tem))
4946         {
4947           *loc = tem;
4948           return 0;
4949         }
4950     }
4951
4952   /* If constants aren't valid addresses, reload the constant address
4953      into a register.  */
4954   if (CONSTANT_P (ad) && ! strict_memory_address_p (mode, ad))
4955     {
4956       /* If AD is an address in the constant pool, the MEM rtx may be shared.
4957          Unshare it so we can safely alter it.  */
4958       if (memrefloc && GET_CODE (ad) == SYMBOL_REF
4959           && CONSTANT_POOL_ADDRESS_P (ad))
4960         {
4961           *memrefloc = copy_rtx (*memrefloc);
4962           loc = &XEXP (*memrefloc, 0);
4963           if (removed_and)
4964             loc = &XEXP (*loc, 0);
4965         }
4966
4967       find_reloads_address_part (ad, loc, MODE_BASE_REG_CLASS (mode),
4968                                  Pmode, opnum, type, ind_levels);
4969       return ! removed_and;
4970     }
4971
4972   return find_reloads_address_1 (mode, ad, 0, loc, opnum, type, ind_levels,
4973                                  insn);
4974 }
4975 \f
4976 /* Find all pseudo regs appearing in AD
4977    that are eliminable in favor of equivalent values
4978    and do not have hard regs; replace them by their equivalents.
4979    INSN, if nonzero, is the insn in which we do the reload.  We put USEs in
4980    front of it for pseudos that we have to replace with stack slots.  */
4981
4982 static rtx
4983 subst_reg_equivs (ad, insn)
4984      rtx ad;
4985      rtx insn;
4986 {
4987   RTX_CODE code = GET_CODE (ad);
4988   int i;
4989   const char *fmt;
4990
4991   switch (code)
4992     {
4993     case HIGH:
4994     case CONST_INT:
4995     case CONST:
4996     case CONST_DOUBLE:
4997     case CONST_VECTOR:
4998     case SYMBOL_REF:
4999     case LABEL_REF:
5000     case PC:
5001     case CC0:
5002       return ad;
5003
5004     case REG:
5005       {
5006         int regno = REGNO (ad);
5007
5008         if (reg_equiv_constant[regno] != 0)
5009           {
5010             subst_reg_equivs_changed = 1;
5011             return reg_equiv_constant[regno];
5012           }
5013         if (reg_equiv_memory_loc[regno] && num_not_at_initial_offset)
5014           {
5015             rtx mem = make_memloc (ad, regno);
5016             if (! rtx_equal_p (mem, reg_equiv_mem[regno]))
5017               {
5018                 subst_reg_equivs_changed = 1;
5019                 /* We mark the USE with QImode so that we recognize it
5020                    as one that can be safely deleted at the end of
5021                    reload.  */
5022                 PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode, ad), insn),
5023                           QImode);
5024                 return mem;
5025               }
5026           }
5027       }
5028       return ad;
5029
5030     case PLUS:
5031       /* Quickly dispose of a common case.  */
5032       if (XEXP (ad, 0) == frame_pointer_rtx
5033           && GET_CODE (XEXP (ad, 1)) == CONST_INT)
5034         return ad;
5035       break;
5036
5037     default:
5038       break;
5039     }
5040
5041   fmt = GET_RTX_FORMAT (code);
5042   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
5043     if (fmt[i] == 'e')
5044       XEXP (ad, i) = subst_reg_equivs (XEXP (ad, i), insn);
5045   return ad;
5046 }
5047 \f
5048 /* Compute the sum of X and Y, making canonicalizations assumed in an
5049    address, namely: sum constant integers, surround the sum of two
5050    constants with a CONST, put the constant as the second operand, and
5051    group the constant on the outermost sum.
5052
5053    This routine assumes both inputs are already in canonical form.  */
5054
5055 rtx
5056 form_sum (x, y)
5057      rtx x, y;
5058 {
5059   rtx tem;
5060   enum machine_mode mode = GET_MODE (x);
5061
5062   if (mode == VOIDmode)
5063     mode = GET_MODE (y);
5064
5065   if (mode == VOIDmode)
5066     mode = Pmode;
5067
5068   if (GET_CODE (x) == CONST_INT)
5069     return plus_constant (y, INTVAL (x));
5070   else if (GET_CODE (y) == CONST_INT)
5071     return plus_constant (x, INTVAL (y));
5072   else if (CONSTANT_P (x))
5073     tem = x, x = y, y = tem;
5074
5075   if (GET_CODE (x) == PLUS && CONSTANT_P (XEXP (x, 1)))
5076     return form_sum (XEXP (x, 0), form_sum (XEXP (x, 1), y));
5077
5078   /* Note that if the operands of Y are specified in the opposite
5079      order in the recursive calls below, infinite recursion will occur.  */
5080   if (GET_CODE (y) == PLUS && CONSTANT_P (XEXP (y, 1)))
5081     return form_sum (form_sum (x, XEXP (y, 0)), XEXP (y, 1));
5082
5083   /* If both constant, encapsulate sum.  Otherwise, just form sum.  A
5084      constant will have been placed second.  */
5085   if (CONSTANT_P (x) && CONSTANT_P (y))
5086     {
5087       if (GET_CODE (x) == CONST)
5088         x = XEXP (x, 0);
5089       if (GET_CODE (y) == CONST)
5090         y = XEXP (y, 0);
5091
5092       return gen_rtx_CONST (VOIDmode, gen_rtx_PLUS (mode, x, y));
5093     }
5094
5095   return gen_rtx_PLUS (mode, x, y);
5096 }
5097 \f
5098 /* If ADDR is a sum containing a pseudo register that should be
5099    replaced with a constant (from reg_equiv_constant),
5100    return the result of doing so, and also apply the associative
5101    law so that the result is more likely to be a valid address.
5102    (But it is not guaranteed to be one.)
5103
5104    Note that at most one register is replaced, even if more are
5105    replaceable.  Also, we try to put the result into a canonical form
5106    so it is more likely to be a valid address.
5107
5108    In all other cases, return ADDR.  */
5109
5110 static rtx
5111 subst_indexed_address (addr)
5112      rtx addr;
5113 {
5114   rtx op0 = 0, op1 = 0, op2 = 0;
5115   rtx tem;
5116   int regno;
5117
5118   if (GET_CODE (addr) == PLUS)
5119     {
5120       /* Try to find a register to replace.  */
5121       op0 = XEXP (addr, 0), op1 = XEXP (addr, 1), op2 = 0;
5122       if (GET_CODE (op0) == REG
5123           && (regno = REGNO (op0)) >= FIRST_PSEUDO_REGISTER
5124           && reg_renumber[regno] < 0
5125           && reg_equiv_constant[regno] != 0)
5126         op0 = reg_equiv_constant[regno];
5127       else if (GET_CODE (op1) == REG
5128                && (regno = REGNO (op1)) >= FIRST_PSEUDO_REGISTER
5129                && reg_renumber[regno] < 0
5130                && reg_equiv_constant[regno] != 0)
5131         op1 = reg_equiv_constant[regno];
5132       else if (GET_CODE (op0) == PLUS
5133                && (tem = subst_indexed_address (op0)) != op0)
5134         op0 = tem;
5135       else if (GET_CODE (op1) == PLUS
5136                && (tem = subst_indexed_address (op1)) != op1)
5137         op1 = tem;
5138       else
5139         return addr;
5140
5141       /* Pick out up to three things to add.  */
5142       if (GET_CODE (op1) == PLUS)
5143         op2 = XEXP (op1, 1), op1 = XEXP (op1, 0);
5144       else if (GET_CODE (op0) == PLUS)
5145         op2 = op1, op1 = XEXP (op0, 1), op0 = XEXP (op0, 0);
5146
5147       /* Compute the sum.  */
5148       if (op2 != 0)
5149         op1 = form_sum (op1, op2);
5150       if (op1 != 0)
5151         op0 = form_sum (op0, op1);
5152
5153       return op0;
5154     }
5155   return addr;
5156 }
5157 \f
5158 /* Update the REG_INC notes for an insn.  It updates all REG_INC
5159    notes for the instruction which refer to REGNO the to refer
5160    to the reload number.
5161
5162    INSN is the insn for which any REG_INC notes need updating.
5163
5164    REGNO is the register number which has been reloaded.
5165
5166    RELOADNUM is the reload number.  */
5167
5168 static void
5169 update_auto_inc_notes (insn, regno, reloadnum)
5170      rtx insn ATTRIBUTE_UNUSED;
5171      int regno ATTRIBUTE_UNUSED;
5172      int reloadnum ATTRIBUTE_UNUSED;
5173 {
5174 #ifdef AUTO_INC_DEC
5175   rtx link;
5176
5177   for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
5178     if (REG_NOTE_KIND (link) == REG_INC
5179         && REGNO (XEXP (link, 0)) == regno)
5180       push_replacement (&XEXP (link, 0), reloadnum, VOIDmode);
5181 #endif
5182 }
5183 \f
5184 /* Record the pseudo registers we must reload into hard registers in a
5185    subexpression of a would-be memory address, X referring to a value
5186    in mode MODE.  (This function is not called if the address we find
5187    is strictly valid.)
5188
5189    CONTEXT = 1 means we are considering regs as index regs,
5190    = 0 means we are considering them as base regs.
5191
5192    OPNUM and TYPE specify the purpose of any reloads made.
5193
5194    IND_LEVELS says how many levels of indirect addressing are
5195    supported at this point in the address.
5196
5197    INSN, if nonzero, is the insn in which we do the reload.  It is used
5198    to determine if we may generate output reloads.
5199
5200    We return nonzero if X, as a whole, is reloaded or replaced.  */
5201
5202 /* Note that we take shortcuts assuming that no multi-reg machine mode
5203    occurs as part of an address.
5204    Also, this is not fully machine-customizable; it works for machines
5205    such as VAXen and 68000's and 32000's, but other possible machines
5206    could have addressing modes that this does not handle right.  */
5207
5208 static int
5209 find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
5210      enum machine_mode mode;
5211      rtx x;
5212      int context;
5213      rtx *loc;
5214      int opnum;
5215      enum reload_type type;
5216      int ind_levels;
5217      rtx insn;
5218 {
5219   RTX_CODE code = GET_CODE (x);
5220
5221   switch (code)
5222     {
5223     case PLUS:
5224       {
5225         rtx orig_op0 = XEXP (x, 0);
5226         rtx orig_op1 = XEXP (x, 1);
5227         RTX_CODE code0 = GET_CODE (orig_op0);
5228         RTX_CODE code1 = GET_CODE (orig_op1);
5229         rtx op0 = orig_op0;
5230         rtx op1 = orig_op1;
5231
5232         if (GET_CODE (op0) == SUBREG)
5233           {
5234             op0 = SUBREG_REG (op0);
5235             code0 = GET_CODE (op0);
5236             if (code0 == REG && REGNO (op0) < FIRST_PSEUDO_REGISTER)
5237               op0 = gen_rtx_REG (word_mode,
5238                                  (REGNO (op0) +
5239                                   subreg_regno_offset (REGNO (SUBREG_REG (orig_op0)),
5240                                                        GET_MODE (SUBREG_REG (orig_op0)),
5241                                                        SUBREG_BYTE (orig_op0),
5242                                                        GET_MODE (orig_op0))));
5243           }
5244
5245         if (GET_CODE (op1) == SUBREG)
5246           {
5247             op1 = SUBREG_REG (op1);
5248             code1 = GET_CODE (op1);
5249             if (code1 == REG && REGNO (op1) < FIRST_PSEUDO_REGISTER)
5250               /* ??? Why is this given op1's mode and above for
5251                  ??? op0 SUBREGs we use word_mode?  */
5252               op1 = gen_rtx_REG (GET_MODE (op1),
5253                                  (REGNO (op1) +
5254                                   subreg_regno_offset (REGNO (SUBREG_REG (orig_op1)),
5255                                                        GET_MODE (SUBREG_REG (orig_op1)),
5256                                                        SUBREG_BYTE (orig_op1),
5257                                                        GET_MODE (orig_op1))));
5258           }
5259
5260         if (code0 == MULT || code0 == SIGN_EXTEND || code0 == TRUNCATE
5261             || code0 == ZERO_EXTEND || code1 == MEM)
5262           {
5263             find_reloads_address_1 (mode, orig_op0, 1, &XEXP (x, 0), opnum,
5264                                     type, ind_levels, insn);
5265             find_reloads_address_1 (mode, orig_op1, 0, &XEXP (x, 1), opnum,
5266                                     type, ind_levels, insn);
5267           }
5268
5269         else if (code1 == MULT || code1 == SIGN_EXTEND || code1 == TRUNCATE
5270                  || code1 == ZERO_EXTEND || code0 == MEM)
5271           {
5272             find_reloads_address_1 (mode, orig_op0, 0, &XEXP (x, 0), opnum,
5273                                     type, ind_levels, insn);
5274             find_reloads_address_1 (mode, orig_op1, 1, &XEXP (x, 1), opnum,
5275                                     type, ind_levels, insn);
5276           }
5277
5278         else if (code0 == CONST_INT || code0 == CONST
5279                  || code0 == SYMBOL_REF || code0 == LABEL_REF)
5280           find_reloads_address_1 (mode, orig_op1, 0, &XEXP (x, 1), opnum,
5281                                   type, ind_levels, insn);
5282
5283         else if (code1 == CONST_INT || code1 == CONST
5284                  || code1 == SYMBOL_REF || code1 == LABEL_REF)
5285           find_reloads_address_1 (mode, orig_op0, 0, &XEXP (x, 0), opnum,
5286                                   type, ind_levels, insn);
5287
5288         else if (code0 == REG && code1 == REG)
5289           {
5290             if (REG_OK_FOR_INDEX_P (op0)
5291                 && REG_MODE_OK_FOR_BASE_P (op1, mode))
5292               return 0;
5293             else if (REG_OK_FOR_INDEX_P (op1)
5294                      && REG_MODE_OK_FOR_BASE_P (op0, mode))
5295               return 0;
5296             else if (REG_MODE_OK_FOR_BASE_P (op1, mode))
5297               find_reloads_address_1 (mode, orig_op0, 1, &XEXP (x, 0), opnum,
5298                                       type, ind_levels, insn);
5299             else if (REG_MODE_OK_FOR_BASE_P (op0, mode))
5300               find_reloads_address_1 (mode, orig_op1, 1, &XEXP (x, 1), opnum,
5301                                       type, ind_levels, insn);
5302             else if (REG_OK_FOR_INDEX_P (op1))
5303               find_reloads_address_1 (mode, orig_op0, 0, &XEXP (x, 0), opnum,
5304                                       type, ind_levels, insn);
5305             else if (REG_OK_FOR_INDEX_P (op0))
5306               find_reloads_address_1 (mode, orig_op1, 0, &XEXP (x, 1), opnum,
5307                                       type, ind_levels, insn);
5308             else
5309               {
5310                 find_reloads_address_1 (mode, orig_op0, 1, &XEXP (x, 0), opnum,
5311                                         type, ind_levels, insn);
5312                 find_reloads_address_1 (mode, orig_op1, 0, &XEXP (x, 1), opnum,
5313                                         type, ind_levels, insn);
5314               }
5315           }
5316
5317         else if (code0 == REG)
5318           {
5319             find_reloads_address_1 (mode, orig_op0, 1, &XEXP (x, 0), opnum,
5320                                     type, ind_levels, insn);
5321             find_reloads_address_1 (mode, orig_op1, 0, &XEXP (x, 1), opnum,
5322                                     type, ind_levels, insn);
5323           }
5324
5325         else if (code1 == REG)
5326           {
5327             find_reloads_address_1 (mode, orig_op1, 1, &XEXP (x, 1), opnum,
5328                                     type, ind_levels, insn);
5329             find_reloads_address_1 (mode, orig_op0, 0, &XEXP (x, 0), opnum,
5330                                     type, ind_levels, insn);
5331           }
5332       }
5333
5334       return 0;
5335
5336     case POST_MODIFY:
5337     case PRE_MODIFY:
5338       {
5339         rtx op0 = XEXP (x, 0);
5340         rtx op1 = XEXP (x, 1);
5341
5342         if (GET_CODE (op1) != PLUS && GET_CODE (op1) != MINUS)
5343           return 0;
5344
5345         /* Currently, we only support {PRE,POST}_MODIFY constructs
5346            where a base register is {inc,dec}remented by the contents
5347            of another register or by a constant value.  Thus, these
5348            operands must match.  */
5349         if (op0 != XEXP (op1, 0))
5350           abort ();
5351
5352         /* Require index register (or constant).  Let's just handle the
5353            register case in the meantime... If the target allows
5354            auto-modify by a constant then we could try replacing a pseudo
5355            register with its equivalent constant where applicable.  */
5356         if (REG_P (XEXP (op1, 1)))
5357           if (!REGNO_OK_FOR_INDEX_P (REGNO (XEXP (op1, 1))))
5358             find_reloads_address_1 (mode, XEXP (op1, 1), 1, &XEXP (op1, 1),
5359                                     opnum, type, ind_levels, insn);
5360
5361         if (REG_P (XEXP (op1, 0)))
5362           {
5363             int regno = REGNO (XEXP (op1, 0));
5364             int reloadnum;
5365
5366             /* A register that is incremented cannot be constant!  */
5367             if (regno >= FIRST_PSEUDO_REGISTER
5368                 && reg_equiv_constant[regno] != 0)
5369               abort ();
5370
5371             /* Handle a register that is equivalent to a memory location
5372                which cannot be addressed directly.  */
5373             if (reg_equiv_memory_loc[regno] != 0
5374                 && (reg_equiv_address[regno] != 0
5375                     || num_not_at_initial_offset))
5376               {
5377                 rtx tem = make_memloc (XEXP (x, 0), regno);
5378
5379                 if (reg_equiv_address[regno]
5380                     || ! rtx_equal_p (tem, reg_equiv_mem[regno]))
5381                   {
5382                     /* First reload the memory location's address.
5383                        We can't use ADDR_TYPE (type) here, because we need to
5384                        write back the value after reading it, hence we actually
5385                        need two registers.  */
5386                     find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
5387                                           &XEXP (tem, 0), opnum,
5388                                           RELOAD_OTHER,
5389                                           ind_levels, insn);
5390
5391                     /* Then reload the memory location into a base
5392                        register.  */
5393                     reloadnum = push_reload (tem, tem, &XEXP (x, 0),
5394                                              &XEXP (op1, 0),
5395                                              MODE_BASE_REG_CLASS (mode),
5396                                              GET_MODE (x), GET_MODE (x), 0,
5397                                              0, opnum, RELOAD_OTHER);
5398
5399                     update_auto_inc_notes (this_insn, regno, reloadnum);
5400                     return 0;
5401                   }
5402               }
5403
5404             if (reg_renumber[regno] >= 0)
5405               regno = reg_renumber[regno];
5406
5407             /* We require a base register here...  */
5408             if (!REGNO_MODE_OK_FOR_BASE_P (regno, GET_MODE (x)))
5409               {
5410                 reloadnum = push_reload (XEXP (op1, 0), XEXP (x, 0),
5411                                          &XEXP (op1, 0), &XEXP (x, 0),
5412                                          MODE_BASE_REG_CLASS (mode),
5413                                          GET_MODE (x), GET_MODE (x), 0, 0,
5414                                          opnum, RELOAD_OTHER);
5415
5416                 update_auto_inc_notes (this_insn, regno, reloadnum);
5417                 return 0;
5418               }
5419           }
5420         else
5421           abort ();
5422       }
5423       return 0;
5424
5425     case POST_INC:
5426     case POST_DEC:
5427     case PRE_INC:
5428     case PRE_DEC:
5429       if (GET_CODE (XEXP (x, 0)) == REG)
5430         {
5431           int regno = REGNO (XEXP (x, 0));
5432           int value = 0;
5433           rtx x_orig = x;
5434
5435           /* A register that is incremented cannot be constant!  */
5436           if (regno >= FIRST_PSEUDO_REGISTER
5437               && reg_equiv_constant[regno] != 0)
5438             abort ();
5439
5440           /* Handle a register that is equivalent to a memory location
5441              which cannot be addressed directly.  */
5442           if (reg_equiv_memory_loc[regno] != 0
5443               && (reg_equiv_address[regno] != 0 || num_not_at_initial_offset))
5444             {
5445               rtx tem = make_memloc (XEXP (x, 0), regno);
5446               if (reg_equiv_address[regno]
5447                   || ! rtx_equal_p (tem, reg_equiv_mem[regno]))
5448                 {
5449                   /* First reload the memory location's address.
5450                      We can't use ADDR_TYPE (type) here, because we need to
5451                      write back the value after reading it, hence we actually
5452                      need two registers.  */
5453                   find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
5454                                         &XEXP (tem, 0), opnum, type,
5455                                         ind_levels, insn);
5456                   /* Put this inside a new increment-expression.  */
5457                   x = gen_rtx_fmt_e (GET_CODE (x), GET_MODE (x), tem);
5458                   /* Proceed to reload that, as if it contained a register.  */
5459                 }
5460             }
5461
5462           /* If we have a hard register that is ok as an index,
5463              don't make a reload.  If an autoincrement of a nice register
5464              isn't "valid", it must be that no autoincrement is "valid".
5465              If that is true and something made an autoincrement anyway,
5466              this must be a special context where one is allowed.
5467              (For example, a "push" instruction.)
5468              We can't improve this address, so leave it alone.  */
5469
5470           /* Otherwise, reload the autoincrement into a suitable hard reg
5471              and record how much to increment by.  */
5472
5473           if (reg_renumber[regno] >= 0)
5474             regno = reg_renumber[regno];
5475           if ((regno >= FIRST_PSEUDO_REGISTER
5476                || !(context ? REGNO_OK_FOR_INDEX_P (regno)
5477                     : REGNO_MODE_OK_FOR_BASE_P (regno, mode))))
5478             {
5479               int reloadnum;
5480
5481               /* If we can output the register afterwards, do so, this
5482                  saves the extra update.
5483                  We can do so if we have an INSN - i.e. no JUMP_INSN nor
5484                  CALL_INSN - and it does not set CC0.
5485                  But don't do this if we cannot directly address the
5486                  memory location, since this will make it harder to
5487                  reuse address reloads, and increases register pressure.
5488                  Also don't do this if we can probably update x directly.  */
5489               rtx equiv = (GET_CODE (XEXP (x, 0)) == MEM
5490                            ? XEXP (x, 0)
5491                            : reg_equiv_mem[regno]);
5492               int icode = (int) add_optab->handlers[(int) Pmode].insn_code;
5493               if (insn && GET_CODE (insn) == INSN && equiv
5494                   && memory_operand (equiv, GET_MODE (equiv))
5495 #ifdef HAVE_cc0
5496                   && ! sets_cc0_p (PATTERN (insn))
5497 #endif
5498                   && ! (icode != CODE_FOR_nothing
5499                         && ((*insn_data[icode].operand[0].predicate)
5500                             (equiv, Pmode))
5501                         && ((*insn_data[icode].operand[1].predicate)
5502                             (equiv, Pmode))))
5503                 {
5504                   /* We use the original pseudo for loc, so that
5505                      emit_reload_insns() knows which pseudo this
5506                      reload refers to and updates the pseudo rtx, not
5507                      its equivalent memory location, as well as the
5508                      corresponding entry in reg_last_reload_reg.  */
5509                   loc = &XEXP (x_orig, 0);
5510                   x = XEXP (x, 0);
5511                   reloadnum
5512                     = push_reload (x, x, loc, loc,
5513                                    (context ? INDEX_REG_CLASS :
5514                                     MODE_BASE_REG_CLASS (mode)),
5515                                    GET_MODE (x), GET_MODE (x), 0, 0,
5516                                    opnum, RELOAD_OTHER);
5517                 }
5518               else
5519                 {
5520                   reloadnum
5521                     = push_reload (x, NULL_RTX, loc, (rtx*) 0,
5522                                    (context ? INDEX_REG_CLASS :
5523                                     MODE_BASE_REG_CLASS (mode)),
5524                                    GET_MODE (x), GET_MODE (x), 0, 0,
5525                                    opnum, type);
5526                   rld[reloadnum].inc
5527                     = find_inc_amount (PATTERN (this_insn), XEXP (x_orig, 0));
5528
5529                   value = 1;
5530                 }
5531
5532               update_auto_inc_notes (this_insn, REGNO (XEXP (x_orig, 0)),
5533                                      reloadnum);
5534             }
5535           return value;
5536         }
5537
5538       else if (GET_CODE (XEXP (x, 0)) == MEM)
5539         {
5540           /* This is probably the result of a substitution, by eliminate_regs,
5541              of an equivalent address for a pseudo that was not allocated to a
5542              hard register.  Verify that the specified address is valid and
5543              reload it into a register.  */
5544           /* Variable `tem' might or might not be used in FIND_REG_INC_NOTE.  */
5545           rtx tem ATTRIBUTE_UNUSED = XEXP (x, 0);
5546           rtx link;
5547           int reloadnum;
5548
5549           /* Since we know we are going to reload this item, don't decrement
5550              for the indirection level.
5551
5552              Note that this is actually conservative:  it would be slightly
5553              more efficient to use the value of SPILL_INDIRECT_LEVELS from
5554              reload1.c here.  */
5555           /* We can't use ADDR_TYPE (type) here, because we need to
5556              write back the value after reading it, hence we actually
5557              need two registers.  */
5558           find_reloads_address (GET_MODE (x), &XEXP (x, 0),
5559                                 XEXP (XEXP (x, 0), 0), &XEXP (XEXP (x, 0), 0),
5560                                 opnum, type, ind_levels, insn);
5561
5562           reloadnum = push_reload (x, NULL_RTX, loc, (rtx*) 0,
5563                                    (context ? INDEX_REG_CLASS :
5564                                     MODE_BASE_REG_CLASS (mode)),
5565                                    GET_MODE (x), VOIDmode, 0, 0, opnum, type);
5566           rld[reloadnum].inc
5567             = find_inc_amount (PATTERN (this_insn), XEXP (x, 0));
5568
5569           link = FIND_REG_INC_NOTE (this_insn, tem);
5570           if (link != 0)
5571             push_replacement (&XEXP (link, 0), reloadnum, VOIDmode);
5572
5573           return 1;
5574         }
5575       return 0;
5576
5577     case MEM:
5578       /* This is probably the result of a substitution, by eliminate_regs, of
5579          an equivalent address for a pseudo that was not allocated to a hard
5580          register.  Verify that the specified address is valid and reload it
5581          into a register.
5582
5583          Since we know we are going to reload this item, don't decrement for
5584          the indirection level.
5585
5586          Note that this is actually conservative:  it would be slightly more
5587          efficient to use the value of SPILL_INDIRECT_LEVELS from
5588          reload1.c here.  */
5589
5590       find_reloads_address (GET_MODE (x), loc, XEXP (x, 0), &XEXP (x, 0),
5591                             opnum, ADDR_TYPE (type), ind_levels, insn);
5592       push_reload (*loc, NULL_RTX, loc, (rtx*) 0,
5593                    (context ? INDEX_REG_CLASS : MODE_BASE_REG_CLASS (mode)),
5594                    GET_MODE (x), VOIDmode, 0, 0, opnum, type);
5595       return 1;
5596
5597     case REG:
5598       {
5599         int regno = REGNO (x);
5600
5601         if (reg_equiv_constant[regno] != 0)
5602           {
5603             find_reloads_address_part (reg_equiv_constant[regno], loc,
5604                                        (context ? INDEX_REG_CLASS :
5605                                         MODE_BASE_REG_CLASS (mode)),
5606                                        GET_MODE (x), opnum, type, ind_levels);
5607             return 1;
5608           }
5609
5610 #if 0 /* This might screw code in reload1.c to delete prior output-reload
5611          that feeds this insn.  */
5612         if (reg_equiv_mem[regno] != 0)
5613           {
5614             push_reload (reg_equiv_mem[regno], NULL_RTX, loc, (rtx*) 0,
5615                          (context ? INDEX_REG_CLASS :
5616                           MODE_BASE_REG_CLASS (mode)),
5617                          GET_MODE (x), VOIDmode, 0, 0, opnum, type);
5618             return 1;
5619           }
5620 #endif
5621
5622         if (reg_equiv_memory_loc[regno]
5623             && (reg_equiv_address[regno] != 0 || num_not_at_initial_offset))
5624           {
5625             rtx tem = make_memloc (x, regno);
5626             if (reg_equiv_address[regno] != 0
5627                 || ! rtx_equal_p (tem, reg_equiv_mem[regno]))
5628               {
5629                 x = tem;
5630                 find_reloads_address (GET_MODE (x), &x, XEXP (x, 0),
5631                                       &XEXP (x, 0), opnum, ADDR_TYPE (type),
5632                                       ind_levels, insn);
5633               }
5634           }
5635
5636         if (reg_renumber[regno] >= 0)
5637           regno = reg_renumber[regno];
5638
5639         if ((regno >= FIRST_PSEUDO_REGISTER
5640              || !(context ? REGNO_OK_FOR_INDEX_P (regno)
5641                   : REGNO_MODE_OK_FOR_BASE_P (regno, mode))))
5642           {
5643             push_reload (x, NULL_RTX, loc, (rtx*) 0,
5644                          (context ? INDEX_REG_CLASS : MODE_BASE_REG_CLASS (mode)),
5645                          GET_MODE (x), VOIDmode, 0, 0, opnum, type);
5646             return 1;
5647           }
5648
5649         /* If a register appearing in an address is the subject of a CLOBBER
5650            in this insn, reload it into some other register to be safe.
5651            The CLOBBER is supposed to make the register unavailable
5652            from before this insn to after it.  */
5653         if (regno_clobbered_p (regno, this_insn, GET_MODE (x), 0))
5654           {
5655             push_reload (x, NULL_RTX, loc, (rtx*) 0,
5656                          (context ? INDEX_REG_CLASS : MODE_BASE_REG_CLASS (mode)),
5657                          GET_MODE (x), VOIDmode, 0, 0, opnum, type);
5658             return 1;
5659           }
5660       }
5661       return 0;
5662
5663     case SUBREG:
5664       if (GET_CODE (SUBREG_REG (x)) == REG)
5665         {
5666           /* If this is a SUBREG of a hard register and the resulting register
5667              is of the wrong class, reload the whole SUBREG.  This avoids
5668              needless copies if SUBREG_REG is multi-word.  */
5669           if (REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
5670             {
5671               int regno ATTRIBUTE_UNUSED = subreg_regno (x);
5672
5673               if (! (context ? REGNO_OK_FOR_INDEX_P (regno)
5674                      : REGNO_MODE_OK_FOR_BASE_P (regno, mode)))
5675                 {
5676                   push_reload (x, NULL_RTX, loc, (rtx*) 0,
5677                                (context ? INDEX_REG_CLASS :
5678                                 MODE_BASE_REG_CLASS (mode)),
5679                                GET_MODE (x), VOIDmode, 0, 0, opnum, type);
5680                   return 1;
5681                 }
5682             }
5683           /* If this is a SUBREG of a pseudo-register, and the pseudo-register
5684              is larger than the class size, then reload the whole SUBREG.  */
5685           else
5686             {
5687               enum reg_class class = (context ? INDEX_REG_CLASS
5688                                       : MODE_BASE_REG_CLASS (mode));
5689               if ((unsigned) CLASS_MAX_NREGS (class, GET_MODE (SUBREG_REG (x)))
5690                   > reg_class_size[class])
5691                 {
5692                   x = find_reloads_subreg_address (x, 0, opnum, type,
5693                                                    ind_levels, insn);
5694                   push_reload (x, NULL_RTX, loc, (rtx*) 0, class,
5695                                GET_MODE (x), VOIDmode, 0, 0, opnum, type);
5696                   return 1;
5697                 }
5698             }
5699         }
5700       break;
5701
5702     default:
5703       break;
5704     }
5705
5706   {
5707     const char *fmt = GET_RTX_FORMAT (code);
5708     int i;
5709
5710     for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
5711       {
5712         if (fmt[i] == 'e')
5713           find_reloads_address_1 (mode, XEXP (x, i), context, &XEXP (x, i),
5714                                   opnum, type, ind_levels, insn);
5715       }
5716   }
5717
5718   return 0;
5719 }
5720 \f
5721 /* X, which is found at *LOC, is a part of an address that needs to be
5722    reloaded into a register of class CLASS.  If X is a constant, or if
5723    X is a PLUS that contains a constant, check that the constant is a
5724    legitimate operand and that we are supposed to be able to load
5725    it into the register.
5726
5727    If not, force the constant into memory and reload the MEM instead.
5728
5729    MODE is the mode to use, in case X is an integer constant.
5730
5731    OPNUM and TYPE describe the purpose of any reloads made.
5732
5733    IND_LEVELS says how many levels of indirect addressing this machine
5734    supports.  */
5735
5736 static void
5737 find_reloads_address_part (x, loc, class, mode, opnum, type, ind_levels)
5738      rtx x;
5739      rtx *loc;
5740      enum reg_class class;
5741      enum machine_mode mode;
5742      int opnum;
5743      enum reload_type type;
5744      int ind_levels;
5745 {
5746   if (CONSTANT_P (x)
5747       && (! LEGITIMATE_CONSTANT_P (x)
5748           || PREFERRED_RELOAD_CLASS (x, class) == NO_REGS))
5749     {
5750       rtx tem;
5751
5752       tem = x = force_const_mem (mode, x);
5753       find_reloads_address (mode, &tem, XEXP (tem, 0), &XEXP (tem, 0),
5754                             opnum, type, ind_levels, 0);
5755     }
5756
5757   else if (GET_CODE (x) == PLUS
5758            && CONSTANT_P (XEXP (x, 1))
5759            && (! LEGITIMATE_CONSTANT_P (XEXP (x, 1))
5760                || PREFERRED_RELOAD_CLASS (XEXP (x, 1), class) == NO_REGS))
5761     {
5762       rtx tem;
5763
5764       tem = force_const_mem (GET_MODE (x), XEXP (x, 1));
5765       x = gen_rtx_PLUS (GET_MODE (x), XEXP (x, 0), tem);
5766       find_reloads_address (mode, &tem, XEXP (tem, 0), &XEXP (tem, 0),
5767                             opnum, type, ind_levels, 0);
5768     }
5769
5770   push_reload (x, NULL_RTX, loc, (rtx*) 0, class,
5771                mode, VOIDmode, 0, 0, opnum, type);
5772 }
5773 \f
5774 /* X, a subreg of a pseudo, is a part of an address that needs to be
5775    reloaded.
5776
5777    If the pseudo is equivalent to a memory location that cannot be directly
5778    addressed, make the necessary address reloads.
5779
5780    If address reloads have been necessary, or if the address is changed
5781    by register elimination, return the rtx of the memory location;
5782    otherwise, return X.
5783
5784    If FORCE_REPLACE is nonzero, unconditionally replace the subreg with the
5785    memory location.
5786
5787    OPNUM and TYPE identify the purpose of the reload.
5788
5789    IND_LEVELS says how many levels of indirect addressing are
5790    supported at this point in the address.
5791
5792    INSN, if nonzero, is the insn in which we do the reload.  It is used
5793    to determine where to put USEs for pseudos that we have to replace with
5794    stack slots.  */
5795
5796 static rtx
5797 find_reloads_subreg_address (x, force_replace, opnum, type,
5798                              ind_levels, insn)
5799      rtx x;
5800      int force_replace;
5801      int opnum;
5802      enum reload_type type;
5803      int ind_levels;
5804      rtx insn;
5805 {
5806   int regno = REGNO (SUBREG_REG (x));
5807
5808   if (reg_equiv_memory_loc[regno])
5809     {
5810       /* If the address is not directly addressable, or if the address is not
5811          offsettable, then it must be replaced.  */
5812       if (! force_replace
5813           && (reg_equiv_address[regno]
5814               || ! offsettable_memref_p (reg_equiv_mem[regno])))
5815         force_replace = 1;
5816
5817       if (force_replace || num_not_at_initial_offset)
5818         {
5819           rtx tem = make_memloc (SUBREG_REG (x), regno);
5820
5821           /* If the address changes because of register elimination, then
5822              it must be replaced.  */
5823           if (force_replace
5824               || ! rtx_equal_p (tem, reg_equiv_mem[regno]))
5825             {
5826               int offset = SUBREG_BYTE (x);
5827               unsigned outer_size = GET_MODE_SIZE (GET_MODE (x));
5828               unsigned inner_size = GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)));
5829
5830               XEXP (tem, 0) = plus_constant (XEXP (tem, 0), offset);
5831               PUT_MODE (tem, GET_MODE (x));
5832
5833               /* If this was a paradoxical subreg that we replaced, the
5834                  resulting memory must be sufficiently aligned to allow
5835                  us to widen the mode of the memory.  */
5836               if (outer_size > inner_size && STRICT_ALIGNMENT)
5837                 {
5838                   rtx base;
5839
5840                   base = XEXP (tem, 0);
5841                   if (GET_CODE (base) == PLUS)
5842                     {
5843                       if (GET_CODE (XEXP (base, 1)) == CONST_INT
5844                           && INTVAL (XEXP (base, 1)) % outer_size != 0)
5845                         return x;
5846                       base = XEXP (base, 0);
5847                     }
5848                   if (GET_CODE (base) != REG
5849                       || (REGNO_POINTER_ALIGN (REGNO (base))
5850                           < outer_size * BITS_PER_UNIT))
5851                     return x;
5852                 }
5853
5854               find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
5855                                     &XEXP (tem, 0), opnum, ADDR_TYPE (type),
5856                                     ind_levels, insn);
5857
5858               /* If this is not a toplevel operand, find_reloads doesn't see
5859                  this substitution.  We have to emit a USE of the pseudo so
5860                  that delete_output_reload can see it.  */
5861               if (replace_reloads && recog_data.operand[opnum] != x)
5862                 /* We mark the USE with QImode so that we recognize it
5863                    as one that can be safely deleted at the end of
5864                    reload.  */
5865                 PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode,
5866                                                          SUBREG_REG (x)),
5867                                             insn), QImode);
5868               x = tem;
5869             }
5870         }
5871     }
5872   return x;
5873 }
5874 \f
5875 /* Substitute into the current INSN the registers into which we have reloaded
5876    the things that need reloading.  The array `replacements'
5877    contains the locations of all pointers that must be changed
5878    and says what to replace them with.
5879
5880    Return the rtx that X translates into; usually X, but modified.  */
5881
5882 void
5883 subst_reloads (insn)
5884      rtx insn;
5885 {
5886   int i;
5887
5888   for (i = 0; i < n_replacements; i++)
5889     {
5890       struct replacement *r = &replacements[i];
5891       rtx reloadreg = rld[r->what].reg_rtx;
5892       if (reloadreg)
5893         {
5894 #ifdef ENABLE_CHECKING
5895           /* Internal consistency test.  Check that we don't modify
5896              anything in the equivalence arrays.  Whenever something from
5897              those arrays needs to be reloaded, it must be unshared before
5898              being substituted into; the equivalence must not be modified.
5899              Otherwise, if the equivalence is used after that, it will
5900              have been modified, and the thing substituted (probably a
5901              register) is likely overwritten and not a usable equivalence.  */
5902           int check_regno;
5903
5904           for (check_regno = 0; check_regno < max_regno; check_regno++)
5905             {
5906 #define CHECK_MODF(ARRAY)                                               \
5907               if (ARRAY[check_regno]                                    \
5908                   && loc_mentioned_in_p (r->where,                      \
5909                                          ARRAY[check_regno]))           \
5910                 abort ()
5911
5912               CHECK_MODF (reg_equiv_constant);
5913               CHECK_MODF (reg_equiv_memory_loc);
5914               CHECK_MODF (reg_equiv_address);
5915               CHECK_MODF (reg_equiv_mem);
5916 #undef CHECK_MODF
5917             }
5918 #endif /* ENABLE_CHECKING */
5919
5920           /* If we're replacing a LABEL_REF with a register, add a
5921              REG_LABEL note to indicate to flow which label this
5922              register refers to.  */
5923           if (GET_CODE (*r->where) == LABEL_REF
5924               && GET_CODE (insn) == JUMP_INSN)
5925             REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_LABEL,
5926                                                   XEXP (*r->where, 0),
5927                                                   REG_NOTES (insn));
5928
5929           /* Encapsulate RELOADREG so its machine mode matches what
5930              used to be there.  Note that gen_lowpart_common will
5931              do the wrong thing if RELOADREG is multi-word.  RELOADREG
5932              will always be a REG here.  */
5933           if (GET_MODE (reloadreg) != r->mode && r->mode != VOIDmode)
5934             reloadreg = gen_rtx_REG (r->mode, REGNO (reloadreg));
5935
5936           /* If we are putting this into a SUBREG and RELOADREG is a
5937              SUBREG, we would be making nested SUBREGs, so we have to fix
5938              this up.  Note that r->where == &SUBREG_REG (*r->subreg_loc).  */
5939
5940           if (r->subreg_loc != 0 && GET_CODE (reloadreg) == SUBREG)
5941             {
5942               if (GET_MODE (*r->subreg_loc)
5943                   == GET_MODE (SUBREG_REG (reloadreg)))
5944                 *r->subreg_loc = SUBREG_REG (reloadreg);
5945               else
5946                 {
5947                   int final_offset =
5948                     SUBREG_BYTE (*r->subreg_loc) + SUBREG_BYTE (reloadreg);
5949
5950                   /* When working with SUBREGs the rule is that the byte
5951                      offset must be a multiple of the SUBREG's mode.  */
5952                   final_offset = (final_offset /
5953                                   GET_MODE_SIZE (GET_MODE (*r->subreg_loc)));
5954                   final_offset = (final_offset *
5955                                   GET_MODE_SIZE (GET_MODE (*r->subreg_loc)));
5956
5957                   *r->where = SUBREG_REG (reloadreg);
5958                   SUBREG_BYTE (*r->subreg_loc) = final_offset;
5959                 }
5960             }
5961           else
5962             *r->where = reloadreg;
5963         }
5964       /* If reload got no reg and isn't optional, something's wrong.  */
5965       else if (! rld[r->what].optional)
5966         abort ();
5967     }
5968 }
5969 \f
5970 /* Make a copy of any replacements being done into X and move those
5971    copies to locations in Y, a copy of X.  */
5972
5973 void
5974 copy_replacements (x, y)
5975      rtx x, y;
5976 {
5977   /* We can't support X being a SUBREG because we might then need to know its
5978      location if something inside it was replaced.  */
5979   if (GET_CODE (x) == SUBREG)
5980     abort ();
5981
5982   copy_replacements_1 (&x, &y, n_replacements);
5983 }
5984
5985 static void
5986 copy_replacements_1 (px, py, orig_replacements)
5987      rtx *px;
5988      rtx *py;
5989      int orig_replacements;
5990 {
5991   int i, j;
5992   rtx x, y;
5993   struct replacement *r;
5994   enum rtx_code code;
5995   const char *fmt;
5996
5997   for (j = 0; j < orig_replacements; j++)
5998     {
5999       if (replacements[j].subreg_loc == px)
6000         {
6001           r = &replacements[n_replacements++];
6002           r->where = replacements[j].where;
6003           r->subreg_loc = py;
6004           r->what = replacements[j].what;
6005           r->mode = replacements[j].mode;
6006         }
6007       else if (replacements[j].where == px)
6008         {
6009           r = &replacements[n_replacements++];
6010           r->where = py;
6011           r->subreg_loc = 0;
6012           r->what = replacements[j].what;
6013           r->mode = replacements[j].mode;
6014         }
6015     }
6016
6017   x = *px;
6018   y = *py;
6019   code = GET_CODE (x);
6020   fmt = GET_RTX_FORMAT (code);
6021
6022   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
6023     {
6024       if (fmt[i] == 'e')
6025         copy_replacements_1 (&XEXP (x, i), &XEXP (y, i), orig_replacements);
6026       else if (fmt[i] == 'E')
6027         for (j = XVECLEN (x, i); --j >= 0; )
6028           copy_replacements_1 (&XVECEXP (x, i, j), &XVECEXP (y, i, j),
6029                                orig_replacements);
6030     }
6031 }
6032
6033 /* Change any replacements being done to *X to be done to *Y.  */
6034
6035 void
6036 move_replacements (x, y)
6037      rtx *x;
6038      rtx *y;
6039 {
6040   int i;
6041
6042   for (i = 0; i < n_replacements; i++)
6043     if (replacements[i].subreg_loc == x)
6044       replacements[i].subreg_loc = y;
6045     else if (replacements[i].where == x)
6046       {
6047         replacements[i].where = y;
6048         replacements[i].subreg_loc = 0;
6049       }
6050 }
6051 \f
6052 /* If LOC was scheduled to be replaced by something, return the replacement.
6053    Otherwise, return *LOC.  */
6054
6055 rtx
6056 find_replacement (loc)
6057      rtx *loc;
6058 {
6059   struct replacement *r;
6060
6061   for (r = &replacements[0]; r < &replacements[n_replacements]; r++)
6062     {
6063       rtx reloadreg = rld[r->what].reg_rtx;
6064
6065       if (reloadreg && r->where == loc)
6066         {
6067           if (r->mode != VOIDmode && GET_MODE (reloadreg) != r->mode)
6068             reloadreg = gen_rtx_REG (r->mode, REGNO (reloadreg));
6069
6070           return reloadreg;
6071         }
6072       else if (reloadreg && r->subreg_loc == loc)
6073         {
6074           /* RELOADREG must be either a REG or a SUBREG.
6075
6076              ??? Is it actually still ever a SUBREG?  If so, why?  */
6077
6078           if (GET_CODE (reloadreg) == REG)
6079             return gen_rtx_REG (GET_MODE (*loc),
6080                                 (REGNO (reloadreg) +
6081                                  subreg_regno_offset (REGNO (SUBREG_REG (*loc)),
6082                                                       GET_MODE (SUBREG_REG (*loc)),
6083                                                       SUBREG_BYTE (*loc),
6084                                                       GET_MODE (*loc))));
6085           else if (GET_MODE (reloadreg) == GET_MODE (*loc))
6086             return reloadreg;
6087           else
6088             {
6089               int final_offset = SUBREG_BYTE (reloadreg) + SUBREG_BYTE (*loc);
6090
6091               /* When working with SUBREGs the rule is that the byte
6092                  offset must be a multiple of the SUBREG's mode.  */
6093               final_offset = (final_offset / GET_MODE_SIZE (GET_MODE (*loc)));
6094               final_offset = (final_offset * GET_MODE_SIZE (GET_MODE (*loc)));
6095               return gen_rtx_SUBREG (GET_MODE (*loc), SUBREG_REG (reloadreg),
6096                                      final_offset);
6097             }
6098         }
6099     }
6100
6101   /* If *LOC is a PLUS, MINUS, or MULT, see if a replacement is scheduled for
6102      what's inside and make a new rtl if so.  */
6103   if (GET_CODE (*loc) == PLUS || GET_CODE (*loc) == MINUS
6104       || GET_CODE (*loc) == MULT)
6105     {
6106       rtx x = find_replacement (&XEXP (*loc, 0));
6107       rtx y = find_replacement (&XEXP (*loc, 1));
6108
6109       if (x != XEXP (*loc, 0) || y != XEXP (*loc, 1))
6110         return gen_rtx_fmt_ee (GET_CODE (*loc), GET_MODE (*loc), x, y);
6111     }
6112
6113   return *loc;
6114 }
6115 \f
6116 /* Return nonzero if register in range [REGNO, ENDREGNO)
6117    appears either explicitly or implicitly in X
6118    other than being stored into (except for earlyclobber operands).
6119
6120    References contained within the substructure at LOC do not count.
6121    LOC may be zero, meaning don't ignore anything.
6122
6123    This is similar to refers_to_regno_p in rtlanal.c except that we
6124    look at equivalences for pseudos that didn't get hard registers.  */
6125
6126 int
6127 refers_to_regno_for_reload_p (regno, endregno, x, loc)
6128      unsigned int regno, endregno;
6129      rtx x;
6130      rtx *loc;
6131 {
6132   int i;
6133   unsigned int r;
6134   RTX_CODE code;
6135   const char *fmt;
6136
6137   if (x == 0)
6138     return 0;
6139
6140  repeat:
6141   code = GET_CODE (x);
6142
6143   switch (code)
6144     {
6145     case REG:
6146       r = REGNO (x);
6147
6148       /* If this is a pseudo, a hard register must not have been allocated.
6149          X must therefore either be a constant or be in memory.  */
6150       if (r >= FIRST_PSEUDO_REGISTER)
6151         {
6152           if (reg_equiv_memory_loc[r])
6153             return refers_to_regno_for_reload_p (regno, endregno,
6154                                                  reg_equiv_memory_loc[r],
6155                                                  (rtx*) 0);
6156
6157           if (reg_equiv_constant[r])
6158             return 0;
6159
6160           abort ();
6161         }
6162
6163       return (endregno > r
6164               && regno < r + (r < FIRST_PSEUDO_REGISTER
6165                               ? HARD_REGNO_NREGS (r, GET_MODE (x))
6166                               : 1));
6167
6168     case SUBREG:
6169       /* If this is a SUBREG of a hard reg, we can see exactly which
6170          registers are being modified.  Otherwise, handle normally.  */
6171       if (GET_CODE (SUBREG_REG (x)) == REG
6172           && REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
6173         {
6174           unsigned int inner_regno = subreg_regno (x);
6175           unsigned int inner_endregno
6176             = inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
6177                              ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
6178
6179           return endregno > inner_regno && regno < inner_endregno;
6180         }
6181       break;
6182
6183     case CLOBBER:
6184     case SET:
6185       if (&SET_DEST (x) != loc
6186           /* Note setting a SUBREG counts as referring to the REG it is in for
6187              a pseudo but not for hard registers since we can
6188              treat each word individually.  */
6189           && ((GET_CODE (SET_DEST (x)) == SUBREG
6190                && loc != &SUBREG_REG (SET_DEST (x))
6191                && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG
6192                && REGNO (SUBREG_REG (SET_DEST (x))) >= FIRST_PSEUDO_REGISTER
6193                && refers_to_regno_for_reload_p (regno, endregno,
6194                                                 SUBREG_REG (SET_DEST (x)),
6195                                                 loc))
6196               /* If the output is an earlyclobber operand, this is
6197                  a conflict.  */
6198               || ((GET_CODE (SET_DEST (x)) != REG
6199                    || earlyclobber_operand_p (SET_DEST (x)))
6200                   && refers_to_regno_for_reload_p (regno, endregno,
6201                                                    SET_DEST (x), loc))))
6202         return 1;
6203
6204       if (code == CLOBBER || loc == &SET_SRC (x))
6205         return 0;
6206       x = SET_SRC (x);
6207       goto repeat;
6208
6209     default:
6210       break;
6211     }
6212
6213   /* X does not match, so try its subexpressions.  */
6214
6215   fmt = GET_RTX_FORMAT (code);
6216   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
6217     {
6218       if (fmt[i] == 'e' && loc != &XEXP (x, i))
6219         {
6220           if (i == 0)
6221             {
6222               x = XEXP (x, 0);
6223               goto repeat;
6224             }
6225           else
6226             if (refers_to_regno_for_reload_p (regno, endregno,
6227                                               XEXP (x, i), loc))
6228               return 1;
6229         }
6230       else if (fmt[i] == 'E')
6231         {
6232           int j;
6233           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
6234             if (loc != &XVECEXP (x, i, j)
6235                 && refers_to_regno_for_reload_p (regno, endregno,
6236                                                  XVECEXP (x, i, j), loc))
6237               return 1;
6238         }
6239     }
6240   return 0;
6241 }
6242
6243 /* Nonzero if modifying X will affect IN.  If X is a register or a SUBREG,
6244    we check if any register number in X conflicts with the relevant register
6245    numbers.  If X is a constant, return 0.  If X is a MEM, return 1 iff IN
6246    contains a MEM (we don't bother checking for memory addresses that can't
6247    conflict because we expect this to be a rare case.
6248
6249    This function is similar to reg_overlap_mentioned_p in rtlanal.c except
6250    that we look at equivalences for pseudos that didn't get hard registers.  */
6251
6252 int
6253 reg_overlap_mentioned_for_reload_p (x, in)
6254      rtx x, in;
6255 {
6256   int regno, endregno;
6257
6258   /* Overly conservative.  */
6259   if (GET_CODE (x) == STRICT_LOW_PART
6260       || GET_RTX_CLASS (GET_CODE (x)) == 'a')
6261     x = XEXP (x, 0);
6262
6263   /* If either argument is a constant, then modifying X can not affect IN.  */
6264   if (CONSTANT_P (x) || CONSTANT_P (in))
6265     return 0;
6266   else if (GET_CODE (x) == SUBREG)
6267     {
6268       regno = REGNO (SUBREG_REG (x));
6269       if (regno < FIRST_PSEUDO_REGISTER)
6270         regno += subreg_regno_offset (REGNO (SUBREG_REG (x)),
6271                                       GET_MODE (SUBREG_REG (x)),
6272                                       SUBREG_BYTE (x),
6273                                       GET_MODE (x));
6274     }
6275   else if (GET_CODE (x) == REG)
6276     {
6277       regno = REGNO (x);
6278
6279       /* If this is a pseudo, it must not have been assigned a hard register.
6280          Therefore, it must either be in memory or be a constant.  */
6281
6282       if (regno >= FIRST_PSEUDO_REGISTER)
6283         {
6284           if (reg_equiv_memory_loc[regno])
6285             return refers_to_mem_for_reload_p (in);
6286           else if (reg_equiv_constant[regno])
6287             return 0;
6288           abort ();
6289         }
6290     }
6291   else if (GET_CODE (x) == MEM)
6292     return refers_to_mem_for_reload_p (in);
6293   else if (GET_CODE (x) == SCRATCH || GET_CODE (x) == PC
6294            || GET_CODE (x) == CC0)
6295     return reg_mentioned_p (x, in);
6296   else if (GET_CODE (x) == PLUS)
6297     return (reg_overlap_mentioned_for_reload_p (XEXP (x, 0), in)
6298             || reg_overlap_mentioned_for_reload_p (XEXP (x, 1), in));
6299   else
6300     abort ();
6301
6302   endregno = regno + (regno < FIRST_PSEUDO_REGISTER
6303                       ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
6304
6305   return refers_to_regno_for_reload_p (regno, endregno, in, (rtx*) 0);
6306 }
6307
6308 /* Return nonzero if anything in X contains a MEM.  Look also for pseudo
6309    registers.  */
6310
6311 int
6312 refers_to_mem_for_reload_p (x)
6313      rtx x;
6314 {
6315   const char *fmt;
6316   int i;
6317
6318   if (GET_CODE (x) == MEM)
6319     return 1;
6320
6321   if (GET_CODE (x) == REG)
6322     return (REGNO (x) >= FIRST_PSEUDO_REGISTER
6323             && reg_equiv_memory_loc[REGNO (x)]);
6324
6325   fmt = GET_RTX_FORMAT (GET_CODE (x));
6326   for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
6327     if (fmt[i] == 'e'
6328         && (GET_CODE (XEXP (x, i)) == MEM
6329             || refers_to_mem_for_reload_p (XEXP (x, i))))
6330       return 1;
6331
6332   return 0;
6333 }
6334 \f
6335 /* Check the insns before INSN to see if there is a suitable register
6336    containing the same value as GOAL.
6337    If OTHER is -1, look for a register in class CLASS.
6338    Otherwise, just see if register number OTHER shares GOAL's value.
6339
6340    Return an rtx for the register found, or zero if none is found.
6341
6342    If RELOAD_REG_P is (short *)1,
6343    we reject any hard reg that appears in reload_reg_rtx
6344    because such a hard reg is also needed coming into this insn.
6345
6346    If RELOAD_REG_P is any other nonzero value,
6347    it is a vector indexed by hard reg number
6348    and we reject any hard reg whose element in the vector is nonnegative
6349    as well as any that appears in reload_reg_rtx.
6350
6351    If GOAL is zero, then GOALREG is a register number; we look
6352    for an equivalent for that register.
6353
6354    MODE is the machine mode of the value we want an equivalence for.
6355    If GOAL is nonzero and not VOIDmode, then it must have mode MODE.
6356
6357    This function is used by jump.c as well as in the reload pass.
6358
6359    If GOAL is the sum of the stack pointer and a constant, we treat it
6360    as if it were a constant except that sp is required to be unchanging.  */
6361
6362 rtx
6363 find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
6364      rtx goal;
6365      rtx insn;
6366      enum reg_class class;
6367      int other;
6368      short *reload_reg_p;
6369      int goalreg;
6370      enum machine_mode mode;
6371 {
6372   rtx p = insn;
6373   rtx goaltry, valtry, value, where;
6374   rtx pat;
6375   int regno = -1;
6376   int valueno;
6377   int goal_mem = 0;
6378   int goal_const = 0;
6379   int goal_mem_addr_varies = 0;
6380   int need_stable_sp = 0;
6381   int nregs;
6382   int valuenregs;
6383
6384   if (goal == 0)
6385     regno = goalreg;
6386   else if (GET_CODE (goal) == REG)
6387     regno = REGNO (goal);
6388   else if (GET_CODE (goal) == MEM)
6389     {
6390       enum rtx_code code = GET_CODE (XEXP (goal, 0));
6391       if (MEM_VOLATILE_P (goal))
6392         return 0;
6393       if (flag_float_store && GET_MODE_CLASS (GET_MODE (goal)) == MODE_FLOAT)
6394         return 0;
6395       /* An address with side effects must be reexecuted.  */
6396       switch (code)
6397         {
6398         case POST_INC:
6399         case PRE_INC:
6400         case POST_DEC:
6401         case PRE_DEC:
6402         case POST_MODIFY:
6403         case PRE_MODIFY:
6404           return 0;
6405         default:
6406           break;
6407         }
6408       goal_mem = 1;
6409     }
6410   else if (CONSTANT_P (goal))
6411     goal_const = 1;
6412   else if (GET_CODE (goal) == PLUS
6413            && XEXP (goal, 0) == stack_pointer_rtx
6414            && CONSTANT_P (XEXP (goal, 1)))
6415     goal_const = need_stable_sp = 1;
6416   else if (GET_CODE (goal) == PLUS
6417            && XEXP (goal, 0) == frame_pointer_rtx
6418            && CONSTANT_P (XEXP (goal, 1)))
6419     goal_const = 1;
6420   else
6421     return 0;
6422
6423   /* Scan insns back from INSN, looking for one that copies
6424      a value into or out of GOAL.
6425      Stop and give up if we reach a label.  */
6426
6427   while (1)
6428     {
6429       p = PREV_INSN (p);
6430       if (p == 0 || GET_CODE (p) == CODE_LABEL)
6431         return 0;
6432
6433       if (GET_CODE (p) == INSN
6434           /* If we don't want spill regs ...  */
6435           && (! (reload_reg_p != 0
6436                  && reload_reg_p != (short *) (HOST_WIDE_INT) 1)
6437               /* ... then ignore insns introduced by reload; they aren't
6438                  useful and can cause results in reload_as_needed to be
6439                  different from what they were when calculating the need for
6440                  spills.  If we notice an input-reload insn here, we will
6441                  reject it below, but it might hide a usable equivalent.
6442                  That makes bad code.  It may even abort: perhaps no reg was
6443                  spilled for this insn because it was assumed we would find
6444                  that equivalent.  */
6445               || INSN_UID (p) < reload_first_uid))
6446         {
6447           rtx tem;
6448           pat = single_set (p);
6449
6450           /* First check for something that sets some reg equal to GOAL.  */
6451           if (pat != 0
6452               && ((regno >= 0
6453                    && true_regnum (SET_SRC (pat)) == regno
6454                    && (valueno = true_regnum (valtry = SET_DEST (pat))) >= 0)
6455                   ||
6456                   (regno >= 0
6457                    && true_regnum (SET_DEST (pat)) == regno
6458                    && (valueno = true_regnum (valtry = SET_SRC (pat))) >= 0)
6459                   ||
6460                   (goal_const && rtx_equal_p (SET_SRC (pat), goal)
6461                    /* When looking for stack pointer + const,
6462                       make sure we don't use a stack adjust.  */
6463                    && !reg_overlap_mentioned_for_reload_p (SET_DEST (pat), goal)
6464                    && (valueno = true_regnum (valtry = SET_DEST (pat))) >= 0)
6465                   || (goal_mem
6466                       && (valueno = true_regnum (valtry = SET_DEST (pat))) >= 0
6467                       && rtx_renumbered_equal_p (goal, SET_SRC (pat)))
6468                   || (goal_mem
6469                       && (valueno = true_regnum (valtry = SET_SRC (pat))) >= 0
6470                       && rtx_renumbered_equal_p (goal, SET_DEST (pat)))
6471                   /* If we are looking for a constant,
6472                      and something equivalent to that constant was copied
6473                      into a reg, we can use that reg.  */
6474                   || (goal_const && REG_NOTES (p) != 0
6475                       && (tem = find_reg_note (p, REG_EQUIV, NULL_RTX))
6476                       && ((rtx_equal_p (XEXP (tem, 0), goal)
6477                            && (valueno
6478                                = true_regnum (valtry = SET_DEST (pat))) >= 0)
6479                           || (GET_CODE (SET_DEST (pat)) == REG
6480                               && GET_CODE (XEXP (tem, 0)) == CONST_DOUBLE
6481                               && (GET_MODE_CLASS (GET_MODE (XEXP (tem, 0)))
6482                                   == MODE_FLOAT)
6483                               && GET_CODE (goal) == CONST_INT
6484                               && 0 != (goaltry
6485                                        = operand_subword (XEXP (tem, 0), 0, 0,
6486                                                           VOIDmode))
6487                               && rtx_equal_p (goal, goaltry)
6488                               && (valtry
6489                                   = operand_subword (SET_DEST (pat), 0, 0,
6490                                                      VOIDmode))
6491                               && (valueno = true_regnum (valtry)) >= 0)))
6492                   || (goal_const && (tem = find_reg_note (p, REG_EQUIV,
6493                                                           NULL_RTX))
6494                       && GET_CODE (SET_DEST (pat)) == REG
6495                       && GET_CODE (XEXP (tem, 0)) == CONST_DOUBLE
6496                       && (GET_MODE_CLASS (GET_MODE (XEXP (tem, 0)))
6497                           == MODE_FLOAT)
6498                       && GET_CODE (goal) == CONST_INT
6499                       && 0 != (goaltry = operand_subword (XEXP (tem, 0), 1, 0,
6500                                                           VOIDmode))
6501                       && rtx_equal_p (goal, goaltry)
6502                       && (valtry
6503                           = operand_subword (SET_DEST (pat), 1, 0, VOIDmode))
6504                       && (valueno = true_regnum (valtry)) >= 0)))
6505             {
6506               if (other >= 0)
6507                 {
6508                   if (valueno != other)
6509                     continue;
6510                 }
6511               else if ((unsigned) valueno >= FIRST_PSEUDO_REGISTER)
6512                 continue;
6513               else
6514                 {
6515                   int i;
6516
6517                   for (i = HARD_REGNO_NREGS (valueno, mode) - 1; i >= 0; i--)
6518                     if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
6519                                              valueno + i))
6520                       break;
6521                   if (i >= 0)
6522                     continue;
6523                 }
6524               value = valtry;
6525               where = p;
6526               break;
6527             }
6528         }
6529     }
6530
6531   /* We found a previous insn copying GOAL into a suitable other reg VALUE
6532      (or copying VALUE into GOAL, if GOAL is also a register).
6533      Now verify that VALUE is really valid.  */
6534
6535   /* VALUENO is the register number of VALUE; a hard register.  */
6536
6537   /* Don't try to re-use something that is killed in this insn.  We want
6538      to be able to trust REG_UNUSED notes.  */
6539   if (REG_NOTES (where) != 0 && find_reg_note (where, REG_UNUSED, value))
6540     return 0;
6541
6542   /* If we propose to get the value from the stack pointer or if GOAL is
6543      a MEM based on the stack pointer, we need a stable SP.  */
6544   if (valueno == STACK_POINTER_REGNUM || regno == STACK_POINTER_REGNUM
6545       || (goal_mem && reg_overlap_mentioned_for_reload_p (stack_pointer_rtx,
6546                                                           goal)))
6547     need_stable_sp = 1;
6548
6549   /* Reject VALUE if the copy-insn moved the wrong sort of datum.  */
6550   if (GET_MODE (value) != mode)
6551     return 0;
6552
6553   /* Reject VALUE if it was loaded from GOAL
6554      and is also a register that appears in the address of GOAL.  */
6555
6556   if (goal_mem && value == SET_DEST (single_set (where))
6557       && refers_to_regno_for_reload_p (valueno,
6558                                        (valueno
6559                                         + HARD_REGNO_NREGS (valueno, mode)),
6560                                        goal, (rtx*) 0))
6561     return 0;
6562
6563   /* Reject registers that overlap GOAL.  */
6564
6565   if (!goal_mem && !goal_const
6566       && regno + (int) HARD_REGNO_NREGS (regno, mode) > valueno
6567       && regno < valueno + (int) HARD_REGNO_NREGS (valueno, mode))
6568     return 0;
6569
6570   nregs = HARD_REGNO_NREGS (regno, mode);
6571   valuenregs = HARD_REGNO_NREGS (valueno, mode);
6572
6573   /* Reject VALUE if it is one of the regs reserved for reloads.
6574      Reload1 knows how to reuse them anyway, and it would get
6575      confused if we allocated one without its knowledge.
6576      (Now that insns introduced by reload are ignored above,
6577      this case shouldn't happen, but I'm not positive.)  */
6578
6579   if (reload_reg_p != 0 && reload_reg_p != (short *) (HOST_WIDE_INT) 1)
6580     {
6581       int i;
6582       for (i = 0; i < valuenregs; ++i)
6583         if (reload_reg_p[valueno + i] >= 0)
6584           return 0;
6585     }
6586
6587   /* Reject VALUE if it is a register being used for an input reload
6588      even if it is not one of those reserved.  */
6589
6590   if (reload_reg_p != 0)
6591     {
6592       int i;
6593       for (i = 0; i < n_reloads; i++)
6594         if (rld[i].reg_rtx != 0 && rld[i].in)
6595           {
6596             int regno1 = REGNO (rld[i].reg_rtx);
6597             int nregs1 = HARD_REGNO_NREGS (regno1,
6598                                            GET_MODE (rld[i].reg_rtx));
6599             if (regno1 < valueno + valuenregs
6600                 && regno1 + nregs1 > valueno)
6601               return 0;
6602           }
6603     }
6604
6605   if (goal_mem)
6606     /* We must treat frame pointer as varying here,
6607        since it can vary--in a nonlocal goto as generated by expand_goto.  */
6608     goal_mem_addr_varies = !CONSTANT_ADDRESS_P (XEXP (goal, 0));
6609
6610   /* Now verify that the values of GOAL and VALUE remain unaltered
6611      until INSN is reached.  */
6612
6613   p = insn;
6614   while (1)
6615     {
6616       p = PREV_INSN (p);
6617       if (p == where)
6618         return value;
6619
6620       /* Don't trust the conversion past a function call
6621          if either of the two is in a call-clobbered register, or memory.  */
6622       if (GET_CODE (p) == CALL_INSN)
6623         {
6624           int i;
6625
6626           if (goal_mem || need_stable_sp)
6627             return 0;
6628
6629           if (regno >= 0 && regno < FIRST_PSEUDO_REGISTER)
6630             for (i = 0; i < nregs; ++i)
6631               if (call_used_regs[regno + i])
6632                 return 0;
6633
6634           if (valueno >= 0 && valueno < FIRST_PSEUDO_REGISTER)
6635             for (i = 0; i < valuenregs; ++i)
6636               if (call_used_regs[valueno + i])
6637                 return 0;
6638 #ifdef NON_SAVING_SETJMP
6639           if (NON_SAVING_SETJMP && find_reg_note (p, REG_SETJMP, NULL))
6640             return 0;
6641 #endif
6642         }
6643
6644       if (INSN_P (p))
6645         {
6646           pat = PATTERN (p);
6647
6648           /* Watch out for unspec_volatile, and volatile asms.  */
6649           if (volatile_insn_p (pat))
6650             return 0;
6651
6652           /* If this insn P stores in either GOAL or VALUE, return 0.
6653              If GOAL is a memory ref and this insn writes memory, return 0.
6654              If GOAL is a memory ref and its address is not constant,
6655              and this insn P changes a register used in GOAL, return 0.  */
6656
6657           if (GET_CODE (pat) == COND_EXEC)
6658             pat = COND_EXEC_CODE (pat);
6659           if (GET_CODE (pat) == SET || GET_CODE (pat) == CLOBBER)
6660             {
6661               rtx dest = SET_DEST (pat);
6662               while (GET_CODE (dest) == SUBREG
6663                      || GET_CODE (dest) == ZERO_EXTRACT
6664                      || GET_CODE (dest) == SIGN_EXTRACT
6665                      || GET_CODE (dest) == STRICT_LOW_PART)
6666                 dest = XEXP (dest, 0);
6667               if (GET_CODE (dest) == REG)
6668                 {
6669                   int xregno = REGNO (dest);
6670                   int xnregs;
6671                   if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
6672                     xnregs = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
6673                   else
6674                     xnregs = 1;
6675                   if (xregno < regno + nregs && xregno + xnregs > regno)
6676                     return 0;
6677                   if (xregno < valueno + valuenregs
6678                       && xregno + xnregs > valueno)
6679                     return 0;
6680                   if (goal_mem_addr_varies
6681                       && reg_overlap_mentioned_for_reload_p (dest, goal))
6682                     return 0;
6683                   if (xregno == STACK_POINTER_REGNUM && need_stable_sp)
6684                     return 0;
6685                 }
6686               else if (goal_mem && GET_CODE (dest) == MEM
6687                        && ! push_operand (dest, GET_MODE (dest)))
6688                 return 0;
6689               else if (GET_CODE (dest) == MEM && regno >= FIRST_PSEUDO_REGISTER
6690                        && reg_equiv_memory_loc[regno] != 0)
6691                 return 0;
6692               else if (need_stable_sp && push_operand (dest, GET_MODE (dest)))
6693                 return 0;
6694             }
6695           else if (GET_CODE (pat) == PARALLEL)
6696             {
6697               int i;
6698               for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)
6699                 {
6700                   rtx v1 = XVECEXP (pat, 0, i);
6701                   if (GET_CODE (v1) == COND_EXEC)
6702                     v1 = COND_EXEC_CODE (v1);
6703                   if (GET_CODE (v1) == SET || GET_CODE (v1) == CLOBBER)
6704                     {
6705                       rtx dest = SET_DEST (v1);
6706                       while (GET_CODE (dest) == SUBREG
6707                              || GET_CODE (dest) == ZERO_EXTRACT
6708                              || GET_CODE (dest) == SIGN_EXTRACT
6709                              || GET_CODE (dest) == STRICT_LOW_PART)
6710                         dest = XEXP (dest, 0);
6711                       if (GET_CODE (dest) == REG)
6712                         {
6713                           int xregno = REGNO (dest);
6714                           int xnregs;
6715                           if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
6716                             xnregs = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
6717                           else
6718                             xnregs = 1;
6719                           if (xregno < regno + nregs
6720                               && xregno + xnregs > regno)
6721                             return 0;
6722                           if (xregno < valueno + valuenregs
6723                               && xregno + xnregs > valueno)
6724                             return 0;
6725                           if (goal_mem_addr_varies
6726                               && reg_overlap_mentioned_for_reload_p (dest,
6727                                                                      goal))
6728                             return 0;
6729                           if (xregno == STACK_POINTER_REGNUM && need_stable_sp)
6730                             return 0;
6731                         }
6732                       else if (goal_mem && GET_CODE (dest) == MEM
6733                                && ! push_operand (dest, GET_MODE (dest)))
6734                         return 0;
6735                       else if (GET_CODE (dest) == MEM && regno >= FIRST_PSEUDO_REGISTER
6736                                && reg_equiv_memory_loc[regno] != 0)
6737                         return 0;
6738                       else if (need_stable_sp
6739                                && push_operand (dest, GET_MODE (dest)))
6740                         return 0;
6741                     }
6742                 }
6743             }
6744
6745           if (GET_CODE (p) == CALL_INSN && CALL_INSN_FUNCTION_USAGE (p))
6746             {
6747               rtx link;
6748
6749               for (link = CALL_INSN_FUNCTION_USAGE (p); XEXP (link, 1) != 0;
6750                    link = XEXP (link, 1))
6751                 {
6752                   pat = XEXP (link, 0);
6753                   if (GET_CODE (pat) == CLOBBER)
6754                     {
6755                       rtx dest = SET_DEST (pat);
6756
6757                       if (GET_CODE (dest) == REG)
6758                         {
6759                           int xregno = REGNO (dest);
6760                           int xnregs
6761                             = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
6762
6763                           if (xregno < regno + nregs
6764                               && xregno + xnregs > regno)
6765                             return 0;
6766                           else if (xregno < valueno + valuenregs
6767                                    && xregno + xnregs > valueno)
6768                             return 0;
6769                           else if (goal_mem_addr_varies
6770                                    && reg_overlap_mentioned_for_reload_p (dest,
6771                                                                      goal))
6772                             return 0;
6773                         }
6774
6775                       else if (goal_mem && GET_CODE (dest) == MEM
6776                                && ! push_operand (dest, GET_MODE (dest)))
6777                         return 0;
6778                       else if (need_stable_sp
6779                                && push_operand (dest, GET_MODE (dest)))
6780                         return 0;
6781                     }
6782                 }
6783             }
6784
6785 #ifdef AUTO_INC_DEC
6786           /* If this insn auto-increments or auto-decrements
6787              either regno or valueno, return 0 now.
6788              If GOAL is a memory ref and its address is not constant,
6789              and this insn P increments a register used in GOAL, return 0.  */
6790           {
6791             rtx link;
6792
6793             for (link = REG_NOTES (p); link; link = XEXP (link, 1))
6794               if (REG_NOTE_KIND (link) == REG_INC
6795                   && GET_CODE (XEXP (link, 0)) == REG)
6796                 {
6797                   int incno = REGNO (XEXP (link, 0));
6798                   if (incno < regno + nregs && incno >= regno)
6799                     return 0;
6800                   if (incno < valueno + valuenregs && incno >= valueno)
6801                     return 0;
6802                   if (goal_mem_addr_varies
6803                       && reg_overlap_mentioned_for_reload_p (XEXP (link, 0),
6804                                                              goal))
6805                     return 0;
6806                 }
6807           }
6808 #endif
6809         }
6810     }
6811 }
6812 \f
6813 /* Find a place where INCED appears in an increment or decrement operator
6814    within X, and return the amount INCED is incremented or decremented by.
6815    The value is always positive.  */
6816
6817 static int
6818 find_inc_amount (x, inced)
6819      rtx x, inced;
6820 {
6821   enum rtx_code code = GET_CODE (x);
6822   const char *fmt;
6823   int i;
6824
6825   if (code == MEM)
6826     {
6827       rtx addr = XEXP (x, 0);
6828       if ((GET_CODE (addr) == PRE_DEC
6829            || GET_CODE (addr) == POST_DEC
6830            || GET_CODE (addr) == PRE_INC
6831            || GET_CODE (addr) == POST_INC)
6832           && XEXP (addr, 0) == inced)
6833         return GET_MODE_SIZE (GET_MODE (x));
6834       else if ((GET_CODE (addr) == PRE_MODIFY
6835                 || GET_CODE (addr) == POST_MODIFY)
6836                && GET_CODE (XEXP (addr, 1)) == PLUS
6837                && XEXP (addr, 0) == XEXP (XEXP (addr, 1), 0)
6838                && XEXP (addr, 0) == inced
6839                && GET_CODE (XEXP (XEXP (addr, 1), 1)) == CONST_INT)
6840         {
6841           i = INTVAL (XEXP (XEXP (addr, 1), 1));
6842           return i < 0 ? -i : i;
6843         }
6844     }
6845
6846   fmt = GET_RTX_FORMAT (code);
6847   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
6848     {
6849       if (fmt[i] == 'e')
6850         {
6851           int tem = find_inc_amount (XEXP (x, i), inced);
6852           if (tem != 0)
6853             return tem;
6854         }
6855       if (fmt[i] == 'E')
6856         {
6857           int j;
6858           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
6859             {
6860               int tem = find_inc_amount (XVECEXP (x, i, j), inced);
6861               if (tem != 0)
6862                 return tem;
6863             }
6864         }
6865     }
6866
6867   return 0;
6868 }
6869 \f
6870 /* Return 1 if register REGNO is the subject of a clobber in insn INSN.
6871    If SETS is nonzero, also consider SETs.  */
6872
6873 int
6874 regno_clobbered_p (regno, insn, mode, sets)
6875      unsigned int regno;
6876      rtx insn;
6877      enum machine_mode mode;
6878      int sets;
6879 {
6880   unsigned int nregs = HARD_REGNO_NREGS (regno, mode);
6881   unsigned int endregno = regno + nregs;
6882
6883   if ((GET_CODE (PATTERN (insn)) == CLOBBER
6884        || (sets && GET_CODE (PATTERN (insn)) == SET))
6885       && GET_CODE (XEXP (PATTERN (insn), 0)) == REG)
6886     {
6887       unsigned int test = REGNO (XEXP (PATTERN (insn), 0));
6888
6889       return test >= regno && test < endregno;
6890     }
6891
6892   if (GET_CODE (PATTERN (insn)) == PARALLEL)
6893     {
6894       int i = XVECLEN (PATTERN (insn), 0) - 1;
6895
6896       for (; i >= 0; i--)
6897         {
6898           rtx elt = XVECEXP (PATTERN (insn), 0, i);
6899           if ((GET_CODE (elt) == CLOBBER
6900                || (sets && GET_CODE (PATTERN (insn)) == SET))
6901               && GET_CODE (XEXP (elt, 0)) == REG)
6902             {
6903               unsigned int test = REGNO (XEXP (elt, 0));
6904
6905               if (test >= regno && test < endregno)
6906                 return 1;
6907             }
6908         }
6909     }
6910
6911   return 0;
6912 }
6913
6914 static const char *const reload_when_needed_name[] =
6915 {
6916   "RELOAD_FOR_INPUT",
6917   "RELOAD_FOR_OUTPUT",
6918   "RELOAD_FOR_INSN",
6919   "RELOAD_FOR_INPUT_ADDRESS",
6920   "RELOAD_FOR_INPADDR_ADDRESS",
6921   "RELOAD_FOR_OUTPUT_ADDRESS",
6922   "RELOAD_FOR_OUTADDR_ADDRESS",
6923   "RELOAD_FOR_OPERAND_ADDRESS",
6924   "RELOAD_FOR_OPADDR_ADDR",
6925   "RELOAD_OTHER",
6926   "RELOAD_FOR_OTHER_ADDRESS"
6927 };
6928
6929 static const char * const reg_class_names[] = REG_CLASS_NAMES;
6930
6931 /* These functions are used to print the variables set by 'find_reloads' */
6932
6933 void
6934 debug_reload_to_stream (f)
6935      FILE *f;
6936 {
6937   int r;
6938   const char *prefix;
6939
6940   if (! f)
6941     f = stderr;
6942   for (r = 0; r < n_reloads; r++)
6943     {
6944       fprintf (f, "Reload %d: ", r);
6945
6946       if (rld[r].in != 0)
6947         {
6948           fprintf (f, "reload_in (%s) = ",
6949                    GET_MODE_NAME (rld[r].inmode));
6950           print_inline_rtx (f, rld[r].in, 24);
6951           fprintf (f, "\n\t");
6952         }
6953
6954       if (rld[r].out != 0)
6955         {
6956           fprintf (f, "reload_out (%s) = ",
6957                    GET_MODE_NAME (rld[r].outmode));
6958           print_inline_rtx (f, rld[r].out, 24);
6959           fprintf (f, "\n\t");
6960         }
6961
6962       fprintf (f, "%s, ", reg_class_names[(int) rld[r].class]);
6963
6964       fprintf (f, "%s (opnum = %d)",
6965                reload_when_needed_name[(int) rld[r].when_needed],
6966                rld[r].opnum);
6967
6968       if (rld[r].optional)
6969         fprintf (f, ", optional");
6970
6971       if (rld[r].nongroup)
6972         fprintf (f, ", nongroup");
6973
6974       if (rld[r].inc != 0)
6975         fprintf (f, ", inc by %d", rld[r].inc);
6976
6977       if (rld[r].nocombine)
6978         fprintf (f, ", can't combine");
6979
6980       if (rld[r].secondary_p)
6981         fprintf (f, ", secondary_reload_p");
6982
6983       if (rld[r].in_reg != 0)
6984         {
6985           fprintf (f, "\n\treload_in_reg: ");
6986           print_inline_rtx (f, rld[r].in_reg, 24);
6987         }
6988
6989       if (rld[r].out_reg != 0)
6990         {
6991           fprintf (f, "\n\treload_out_reg: ");
6992           print_inline_rtx (f, rld[r].out_reg, 24);
6993         }
6994
6995       if (rld[r].reg_rtx != 0)
6996         {
6997           fprintf (f, "\n\treload_reg_rtx: ");
6998           print_inline_rtx (f, rld[r].reg_rtx, 24);
6999         }
7000
7001       prefix = "\n\t";
7002       if (rld[r].secondary_in_reload != -1)
7003         {
7004           fprintf (f, "%ssecondary_in_reload = %d",
7005                    prefix, rld[r].secondary_in_reload);
7006           prefix = ", ";
7007         }
7008
7009       if (rld[r].secondary_out_reload != -1)
7010         fprintf (f, "%ssecondary_out_reload = %d\n",
7011                  prefix, rld[r].secondary_out_reload);
7012
7013       prefix = "\n\t";
7014       if (rld[r].secondary_in_icode != CODE_FOR_nothing)
7015         {
7016           fprintf (f, "%ssecondary_in_icode = %s", prefix,
7017                    insn_data[rld[r].secondary_in_icode].name);
7018           prefix = ", ";
7019         }
7020
7021       if (rld[r].secondary_out_icode != CODE_FOR_nothing)
7022         fprintf (f, "%ssecondary_out_icode = %s", prefix,
7023                  insn_data[rld[r].secondary_out_icode].name);
7024
7025       fprintf (f, "\n");
7026     }
7027 }
7028
7029 void
7030 debug_reload ()
7031 {
7032   debug_reload_to_stream (stderr);
7033 }