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