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