gcc/reload.c

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