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