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                   if (!subreg_offset_representable_p
2884                         (REGNO (SUBREG_REG (operand)),
2885                          GET_MODE (SUBREG_REG (operand)),
2886                          SUBREG_BYTE (operand),
2887                          GET_MODE (operand)))
2888                      force_reload = 1;
2889                   offset += subreg_regno_offset (REGNO (SUBREG_REG (operand)),
2890                                                  GET_MODE (SUBREG_REG (operand)),
2891                                                  SUBREG_BYTE (operand),
2892                                                  GET_MODE (operand));
2893                 }
2894               operand = SUBREG_REG (operand);
2895               /* Force reload if this is a constant or PLUS or if there may
2896                  be a problem accessing OPERAND in the outer mode.  */
2897               if (CONSTANT_P (operand)
2898                   || GET_CODE (operand) == PLUS
2899                   /* We must force a reload of paradoxical SUBREGs
2900                      of a MEM because the alignment of the inner value
2901                      may not be enough to do the outer reference.  On
2902                      big-endian machines, it may also reference outside
2903                      the object.
2904
2905                      On machines that extend byte operations and we have a
2906                      SUBREG where both the inner and outer modes are no wider
2907                      than a word and the inner mode is narrower, is integral,
2908                      and gets extended when loaded from memory, combine.c has
2909                      made assumptions about the behavior of the machine in such
2910                      register access.  If the data is, in fact, in memory we
2911                      must always load using the size assumed to be in the
2912                      register and let the insn do the different-sized
2913                      accesses.
2914
2915                      This is doubly true if WORD_REGISTER_OPERATIONS.  In
2916                      this case eliminate_regs has left non-paradoxical
2917                      subregs for push_reloads to see.  Make sure it does
2918                      by forcing the reload.
2919
2920                      ??? When is it right at this stage to have a subreg
2921                      of a mem that is _not_ to be handled specially?  IMO
2922                      those should have been reduced to just a mem.  */
2923                   || ((GET_CODE (operand) == MEM
2924                        || (GET_CODE (operand)== REG
2925                            && REGNO (operand) >= FIRST_PSEUDO_REGISTER))
2926 #ifndef WORD_REGISTER_OPERATIONS
2927                       && (((GET_MODE_BITSIZE (GET_MODE (operand))
2928                             < BIGGEST_ALIGNMENT)
2929                            && (GET_MODE_SIZE (operand_mode[i])
2930                                > GET_MODE_SIZE (GET_MODE (operand))))
2931                           || (GET_CODE (operand) == MEM && BYTES_BIG_ENDIAN)
2932 #ifdef LOAD_EXTEND_OP
2933                           || (GET_MODE_SIZE (operand_mode[i]) <= UNITS_PER_WORD
2934                               && (GET_MODE_SIZE (GET_MODE (operand))
2935                                   <= UNITS_PER_WORD)
2936                               && (GET_MODE_SIZE (operand_mode[i])
2937                                   > GET_MODE_SIZE (GET_MODE (operand)))
2938                               && INTEGRAL_MODE_P (GET_MODE (operand))
2939                               && LOAD_EXTEND_OP (GET_MODE (operand)) != NIL)
2940 #endif
2941                           )
2942 #endif
2943                       )
2944                   )
2945                 force_reload = 1;
2946             }
2947
2948           this_alternative[i] = (int) NO_REGS;
2949           this_alternative_win[i] = 0;
2950           this_alternative_match_win[i] = 0;
2951           this_alternative_offmemok[i] = 0;
2952           this_alternative_earlyclobber[i] = 0;
2953           this_alternative_matches[i] = -1;
2954
2955           /* An empty constraint or empty alternative
2956              allows anything which matched the pattern.  */
2957           if (*p == 0 || *p == ',')
2958             win = 1, badop = 0;
2959
2960           /* Scan this alternative's specs for this operand;
2961              set WIN if the operand fits any letter in this alternative.
2962              Otherwise, clear BADOP if this operand could
2963              fit some letter after reloads,
2964              or set WINREG if this operand could fit after reloads
2965              provided the constraint allows some registers.  */
2966
2967           do
2968             switch ((c = *p, len = CONSTRAINT_LEN (c, p)), c)
2969               {
2970               case '\0':
2971                 len = 0;
2972                 break;
2973               case ',':
2974                 c = '\0';
2975                 break;
2976
2977               case '=':  case '+':  case '*':
2978                 break;
2979
2980               case '%':
2981                 /* The last operand should not be marked commutative.  */
2982                 if (i != noperands - 1)
2983                   commutative = i;
2984                 break;
2985
2986               case '?':
2987                 reject += 6;
2988                 break;
2989
2990               case '!':
2991                 reject = 600;
2992                 break;
2993
2994               case '#':
2995                 /* Ignore rest of this alternative as far as
2996                    reloading is concerned.  */
2997                 do
2998                   p++;
2999                 while (*p && *p != ',');
3000                 len = 0;
3001                 break;
3002
3003               case '0':  case '1':  case '2':  case '3':  case '4':
3004               case '5':  case '6':  case '7':  case '8':  case '9':
3005                 m = strtoul (p, &end, 10);
3006                 p = end;
3007                 len = 0;
3008
3009                 this_alternative_matches[i] = m;
3010                 /* We are supposed to match a previous operand.
3011                    If we do, we win if that one did.
3012                    If we do not, count both of the operands as losers.
3013                    (This is too conservative, since most of the time
3014                    only a single reload insn will be needed to make
3015                    the two operands win.  As a result, this alternative
3016                    may be rejected when it is actually desirable.)  */
3017                 if ((swapped && (m != commutative || i != commutative + 1))
3018                     /* If we are matching as if two operands were swapped,
3019                        also pretend that operands_match had been computed
3020                        with swapped.
3021                        But if I is the second of those and C is the first,
3022                        don't exchange them, because operands_match is valid
3023                        only on one side of its diagonal.  */
3024                     ? (operands_match
3025                        [(m == commutative || m == commutative + 1)
3026                        ? 2 * commutative + 1 - m : m]
3027                        [(i == commutative || i == commutative + 1)
3028                        ? 2 * commutative + 1 - i : i])
3029                     : operands_match[m][i])
3030                   {
3031                     /* If we are matching a non-offsettable address where an
3032                        offsettable address was expected, then we must reject
3033                        this combination, because we can't reload it.  */
3034                     if (this_alternative_offmemok[m]
3035                         && GET_CODE (recog_data.operand[m]) == MEM
3036                         && this_alternative[m] == (int) NO_REGS
3037                         && ! this_alternative_win[m])
3038                       bad = 1;
3039
3040                     did_match = this_alternative_win[m];
3041                   }
3042                 else
3043                   {
3044                     /* Operands don't match.  */
3045                     rtx value;
3046                     /* Retroactively mark the operand we had to match
3047                        as a loser, if it wasn't already.  */
3048                     if (this_alternative_win[m])
3049                       losers++;
3050                     this_alternative_win[m] = 0;
3051                     if (this_alternative[m] == (int) NO_REGS)
3052                       bad = 1;
3053                     /* But count the pair only once in the total badness of
3054                        this alternative, if the pair can be a dummy reload.  */
3055                     value
3056                       = find_dummy_reload (recog_data.operand[i],
3057                                            recog_data.operand[m],
3058                                            recog_data.operand_loc[i],
3059                                            recog_data.operand_loc[m],
3060                                            operand_mode[i], operand_mode[m],
3061                                            this_alternative[m], -1,
3062                                            this_alternative_earlyclobber[m]);
3063
3064                     if (value != 0)
3065                       losers--;
3066                   }
3067                 /* This can be fixed with reloads if the operand
3068                    we are supposed to match can be fixed with reloads.  */
3069                 badop = 0;
3070                 this_alternative[i] = this_alternative[m];
3071
3072                 /* If we have to reload this operand and some previous
3073                    operand also had to match the same thing as this
3074                    operand, we don't know how to do that.  So reject this
3075                    alternative.  */
3076                 if (! did_match || force_reload)
3077                   for (j = 0; j < i; j++)
3078                     if (this_alternative_matches[j]
3079                         == this_alternative_matches[i])
3080                       badop = 1;
3081                 break;
3082
3083               case 'p':
3084                 /* All necessary reloads for an address_operand
3085                    were handled in find_reloads_address.  */
3086                 this_alternative[i] = (int) MODE_BASE_REG_CLASS (VOIDmode);
3087                 win = 1;
3088                 badop = 0;
3089                 break;
3090
3091               case 'm':
3092                 if (force_reload)
3093                   break;
3094                 if (GET_CODE (operand) == MEM
3095                     || (GET_CODE (operand) == REG
3096                         && REGNO (operand) >= FIRST_PSEUDO_REGISTER
3097                         && reg_renumber[REGNO (operand)] < 0))
3098                   win = 1;
3099                 if (CONSTANT_P (operand)
3100                     /* force_const_mem does not accept HIGH.  */
3101                     && GET_CODE (operand) != HIGH)
3102                   badop = 0;
3103                 constmemok = 1;
3104                 break;
3105
3106               case '<':
3107                 if (GET_CODE (operand) == MEM
3108                     && ! address_reloaded[i]
3109                     && (GET_CODE (XEXP (operand, 0)) == PRE_DEC
3110                         || GET_CODE (XEXP (operand, 0)) == POST_DEC))
3111                   win = 1;
3112                 break;
3113
3114               case '>':
3115                 if (GET_CODE (operand) == MEM
3116                     && ! address_reloaded[i]
3117                     && (GET_CODE (XEXP (operand, 0)) == PRE_INC
3118                         || GET_CODE (XEXP (operand, 0)) == POST_INC))
3119                   win = 1;
3120                 break;
3121
3122                 /* Memory operand whose address is not offsettable.  */
3123               case 'V':
3124                 if (force_reload)
3125                   break;
3126                 if (GET_CODE (operand) == MEM
3127                     && ! (ind_levels ? offsettable_memref_p (operand)
3128                           : offsettable_nonstrict_memref_p (operand))
3129                     /* Certain mem addresses will become offsettable
3130                        after they themselves are reloaded.  This is important;
3131                        we don't want our own handling of unoffsettables
3132                        to override the handling of reg_equiv_address.  */
3133                     && !(GET_CODE (XEXP (operand, 0)) == REG
3134                          && (ind_levels == 0
3135                              || reg_equiv_address[REGNO (XEXP (operand, 0))] != 0)))
3136                   win = 1;
3137                 break;
3138
3139                 /* Memory operand whose address is offsettable.  */
3140               case 'o':
3141                 if (force_reload)
3142                   break;
3143                 if ((GET_CODE (operand) == MEM
3144                      /* If IND_LEVELS, find_reloads_address won't reload a
3145                         pseudo that didn't get a hard reg, so we have to
3146                         reject that case.  */
3147                      && ((ind_levels ? offsettable_memref_p (operand)
3148                           : offsettable_nonstrict_memref_p (operand))
3149                          /* A reloaded address is offsettable because it is now
3150                             just a simple register indirect.  */
3151                          || address_reloaded[i]))
3152                     || (GET_CODE (operand) == REG
3153                         && REGNO (operand) >= FIRST_PSEUDO_REGISTER
3154                         && reg_renumber[REGNO (operand)] < 0
3155                         /* If reg_equiv_address is nonzero, we will be
3156                            loading it into a register; hence it will be
3157                            offsettable, but we cannot say that reg_equiv_mem
3158                            is offsettable without checking.  */
3159                         && ((reg_equiv_mem[REGNO (operand)] != 0
3160                              && offsettable_memref_p (reg_equiv_mem[REGNO (operand)]))
3161                             || (reg_equiv_address[REGNO (operand)] != 0))))
3162                   win = 1;
3163                 /* force_const_mem does not accept HIGH.  */
3164                 if ((CONSTANT_P (operand) && GET_CODE (operand) != HIGH)
3165                     || GET_CODE (operand) == MEM)
3166                   badop = 0;
3167                 constmemok = 1;
3168                 offmemok = 1;
3169                 break;
3170
3171               case '&':
3172                 /* Output operand that is stored before the need for the
3173                    input operands (and their index registers) is over.  */
3174                 earlyclobber = 1, this_earlyclobber = 1;
3175                 break;
3176
3177               case 'E':
3178               case 'F':
3179                 if (GET_CODE (operand) == CONST_DOUBLE
3180                     || (GET_CODE (operand) == CONST_VECTOR
3181                         && (GET_MODE_CLASS (GET_MODE (operand))
3182                             == MODE_VECTOR_FLOAT)))
3183                   win = 1;
3184                 break;
3185
3186               case 'G':
3187               case 'H':
3188                 if (GET_CODE (operand) == CONST_DOUBLE
3189                     && CONST_DOUBLE_OK_FOR_CONSTRAINT_P (operand, c, p))
3190                   win = 1;
3191                 break;
3192
3193               case 's':
3194                 if (GET_CODE (operand) == CONST_INT
3195                     || (GET_CODE (operand) == CONST_DOUBLE
3196                         && GET_MODE (operand) == VOIDmode))
3197                   break;
3198               case 'i':
3199                 if (CONSTANT_P (operand)
3200 #ifdef LEGITIMATE_PIC_OPERAND_P
3201                     && (! flag_pic || LEGITIMATE_PIC_OPERAND_P (operand))
3202 #endif
3203                     )
3204                   win = 1;
3205                 break;
3206
3207               case 'n':
3208                 if (GET_CODE (operand) == CONST_INT
3209                     || (GET_CODE (operand) == CONST_DOUBLE
3210                         && GET_MODE (operand) == VOIDmode))
3211                   win = 1;
3212                 break;
3213
3214               case 'I':
3215               case 'J':
3216               case 'K':
3217               case 'L':
3218               case 'M':
3219               case 'N':
3220               case 'O':
3221               case 'P':
3222                 if (GET_CODE (operand) == CONST_INT
3223                     && CONST_OK_FOR_CONSTRAINT_P (INTVAL (operand), c, p))
3224                   win = 1;
3225                 break;
3226
3227               case 'X':
3228                 win = 1;
3229                 break;
3230
3231               case 'g':
3232                 if (! force_reload
3233                     /* A PLUS is never a valid operand, but reload can make
3234                        it from a register when eliminating registers.  */
3235                     && GET_CODE (operand) != PLUS
3236                     /* A SCRATCH is not a valid operand.  */
3237                     && GET_CODE (operand) != SCRATCH
3238 #ifdef LEGITIMATE_PIC_OPERAND_P
3239                     && (! CONSTANT_P (operand)
3240                         || ! flag_pic
3241                         || LEGITIMATE_PIC_OPERAND_P (operand))
3242 #endif
3243                     && (GENERAL_REGS == ALL_REGS
3244                         || GET_CODE (operand) != REG
3245                         || (REGNO (operand) >= FIRST_PSEUDO_REGISTER
3246                             && reg_renumber[REGNO (operand)] < 0)))
3247                   win = 1;
3248                 /* Drop through into 'r' case.  */
3249
3250               case 'r':
3251                 this_alternative[i]
3252                   = (int) reg_class_subunion[this_alternative[i]][(int) GENERAL_REGS];
3253                 goto reg;
3254
3255               default:
3256                 if (REG_CLASS_FROM_CONSTRAINT (c, p) == NO_REGS)
3257                   {
3258 #ifdef EXTRA_CONSTRAINT_STR
3259                     if (EXTRA_MEMORY_CONSTRAINT (c, p))
3260                       {
3261                         if (force_reload)
3262                           break;
3263                         if (EXTRA_CONSTRAINT_STR (operand, c, p))
3264                           win = 1;
3265                         /* If the address was already reloaded,
3266                            we win as well.  */
3267                         if (GET_CODE (operand) == MEM && address_reloaded[i])
3268                           win = 1;
3269                         /* Likewise if the address will be reloaded because
3270                            reg_equiv_address is nonzero.  For reg_equiv_mem
3271                            we have to check.  */
3272                         if (GET_CODE (operand) == REG
3273                             && REGNO (operand) >= FIRST_PSEUDO_REGISTER
3274                             && reg_renumber[REGNO (operand)] < 0
3275                             && ((reg_equiv_mem[REGNO (operand)] != 0
3276                                  && EXTRA_CONSTRAINT_STR (reg_equiv_mem[REGNO (operand)], c, p))
3277                                 || (reg_equiv_address[REGNO (operand)] != 0)))
3278                           win = 1;
3279
3280                         /* If we didn't already win, we can reload
3281                            constants via force_const_mem, and other
3282                            MEMs by reloading the address like for 'o'.  */
3283                         if ((CONSTANT_P (operand) && GET_CODE (operand) != HIGH)
3284                             || GET_CODE (operand) == MEM)
3285                           badop = 0;
3286                         constmemok = 1;
3287                         offmemok = 1;
3288                         break;
3289                       }
3290                     if (EXTRA_ADDRESS_CONSTRAINT (c, p))
3291                       {
3292                         if (EXTRA_CONSTRAINT_STR (operand, c, p))
3293                           win = 1;
3294
3295                         /* If we didn't already win, we can reload
3296                            the address into a base register.  */
3297                         this_alternative[i] = (int) MODE_BASE_REG_CLASS (VOIDmode);
3298                         badop = 0;
3299                         break;
3300                       }
3301
3302                     if (EXTRA_CONSTRAINT_STR (operand, c, p))
3303                       win = 1;
3304 #endif
3305                     break;
3306                   }
3307
3308                 this_alternative[i]
3309                   = (int) (reg_class_subunion
3310                            [this_alternative[i]]
3311                            [(int) REG_CLASS_FROM_CONSTRAINT (c, p)]);
3312               reg:
3313                 if (GET_MODE (operand) == BLKmode)
3314                   break;
3315                 winreg = 1;
3316                 if (GET_CODE (operand) == REG
3317                     && reg_fits_class_p (operand, this_alternative[i],
3318                                          offset, GET_MODE (recog_data.operand[i])))
3319                   win = 1;
3320                 break;
3321               }
3322           while ((p += len), c);
3323
3324           constraints[i] = p;
3325
3326           /* If this operand could be handled with a reg,
3327              and some reg is allowed, then this operand can be handled.  */
3328           if (winreg && this_alternative[i] != (int) NO_REGS)
3329             badop = 0;
3330
3331           /* Record which operands fit this alternative.  */
3332           this_alternative_earlyclobber[i] = earlyclobber;
3333           if (win && ! force_reload)
3334             this_alternative_win[i] = 1;
3335           else if (did_match && ! force_reload)
3336             this_alternative_match_win[i] = 1;
3337           else
3338             {
3339               int const_to_mem = 0;
3340
3341               this_alternative_offmemok[i] = offmemok;
3342               losers++;
3343               if (badop)
3344                 bad = 1;
3345               /* Alternative loses if it has no regs for a reg operand.  */
3346               if (GET_CODE (operand) == REG
3347                   && this_alternative[i] == (int) NO_REGS
3348                   && this_alternative_matches[i] < 0)
3349                 bad = 1;
3350
3351               /* If this is a constant that is reloaded into the desired
3352                  class by copying it to memory first, count that as another
3353                  reload.  This is consistent with other code and is
3354                  required to avoid choosing another alternative when
3355                  the constant is moved into memory by this function on
3356                  an early reload pass.  Note that the test here is
3357                  precisely the same as in the code below that calls
3358                  force_const_mem.  */
3359               if (CONSTANT_P (operand)
3360                   /* force_const_mem does not accept HIGH.  */
3361                   && GET_CODE (operand) != HIGH
3362                   && ((PREFERRED_RELOAD_CLASS (operand,
3363                                                (enum reg_class) this_alternative[i])
3364                        == NO_REGS)
3365                       || no_input_reloads)
3366                   && operand_mode[i] != VOIDmode)
3367                 {
3368                   const_to_mem = 1;
3369                   if (this_alternative[i] != (int) NO_REGS)
3370                     losers++;
3371                 }
3372
3373               /* If we can't reload this value at all, reject this
3374                  alternative.  Note that we could also lose due to
3375                  LIMIT_RELOAD_RELOAD_CLASS, but we don't check that
3376                  here.  */
3377
3378               if (! CONSTANT_P (operand)
3379                   && (enum reg_class) this_alternative[i] != NO_REGS
3380                   && (PREFERRED_RELOAD_CLASS (operand,
3381                                               (enum reg_class) this_alternative[i])
3382                       == NO_REGS))
3383                 bad = 1;
3384
3385               /* Alternative loses if it requires a type of reload not
3386                  permitted for this insn.  We can always reload SCRATCH
3387                  and objects with a REG_UNUSED note.  */
3388               else if (GET_CODE (operand) != SCRATCH
3389                        && modified[i] != RELOAD_READ && no_output_reloads
3390                        && ! find_reg_note (insn, REG_UNUSED, operand))
3391                 bad = 1;
3392               else if (modified[i] != RELOAD_WRITE && no_input_reloads
3393                        && ! const_to_mem)
3394                 bad = 1;
3395
3396               /* We prefer to reload pseudos over reloading other things,
3397                  since such reloads may be able to be eliminated later.
3398                  If we are reloading a SCRATCH, we won't be generating any
3399                  insns, just using a register, so it is also preferred.
3400                  So bump REJECT in other cases.  Don't do this in the
3401                  case where we are forcing a constant into memory and
3402                  it will then win since we don't want to have a different
3403                  alternative match then.  */
3404               if (! (GET_CODE (operand) == REG
3405                      && REGNO (operand) >= FIRST_PSEUDO_REGISTER)
3406                   && GET_CODE (operand) != SCRATCH
3407                   && ! (const_to_mem && constmemok))
3408                 reject += 2;
3409
3410               /* Input reloads can be inherited more often than output
3411                  reloads can be removed, so penalize output reloads.  */
3412               if (operand_type[i] != RELOAD_FOR_INPUT
3413                   && GET_CODE (operand) != SCRATCH)
3414                 reject++;
3415             }
3416
3417           /* If this operand is a pseudo register that didn't get a hard
3418              reg and this alternative accepts some register, see if the
3419              class that we want is a subset of the preferred class for this
3420              register.  If not, but it intersects that class, use the
3421              preferred class instead.  If it does not intersect the preferred
3422              class, show that usage of this alternative should be discouraged;
3423              it will be discouraged more still if the register is `preferred
3424              or nothing'.  We do this because it increases the chance of
3425              reusing our spill register in a later insn and avoiding a pair
3426              of memory stores and loads.
3427
3428              Don't bother with this if this alternative will accept this
3429              operand.
3430
3431              Don't do this for a multiword operand, since it is only a
3432              small win and has the risk of requiring more spill registers,
3433              which could cause a large loss.
3434
3435              Don't do this if the preferred class has only one register
3436              because we might otherwise exhaust the class.  */
3437
3438           if (! win && ! did_match
3439               && this_alternative[i] != (int) NO_REGS
3440               && GET_MODE_SIZE (operand_mode[i]) <= UNITS_PER_WORD
3441               && reg_class_size[(int) preferred_class[i]] > 1)
3442             {
3443               if (! reg_class_subset_p (this_alternative[i],
3444                                         preferred_class[i]))
3445                 {
3446                   /* Since we don't have a way of forming the intersection,
3447                      we just do something special if the preferred class
3448                      is a subset of the class we have; that's the most
3449                      common case anyway.  */
3450                   if (reg_class_subset_p (preferred_class[i],
3451                                           this_alternative[i]))
3452                     this_alternative[i] = (int) preferred_class[i];
3453                   else
3454                     reject += (2 + 2 * pref_or_nothing[i]);
3455                 }
3456             }
3457         }
3458
3459       /* Now see if any output operands that are marked "earlyclobber"
3460          in this alternative conflict with any input operands
3461          or any memory addresses.  */
3462
3463       for (i = 0; i < noperands; i++)
3464         if (this_alternative_earlyclobber[i]
3465             && (this_alternative_win[i] || this_alternative_match_win[i]))
3466           {
3467             struct decomposition early_data;
3468
3469             early_data = decompose (recog_data.operand[i]);
3470
3471             if (modified[i] == RELOAD_READ)
3472               abort ();
3473
3474             if (this_alternative[i] == NO_REGS)
3475               {
3476                 this_alternative_earlyclobber[i] = 0;
3477                 if (this_insn_is_asm)
3478                   error_for_asm (this_insn,
3479                                  "`&' constraint used with no register class");
3480                 else
3481                   abort ();
3482               }
3483
3484             for (j = 0; j < noperands; j++)
3485               /* Is this an input operand or a memory ref?  */
3486               if ((GET_CODE (recog_data.operand[j]) == MEM
3487                    || modified[j] != RELOAD_WRITE)
3488                   && j != i
3489                   /* Ignore things like match_operator operands.  */
3490                   && *recog_data.constraints[j] != 0
3491                   /* Don't count an input operand that is constrained to match
3492                      the early clobber operand.  */
3493                   && ! (this_alternative_matches[j] == i
3494                         && rtx_equal_p (recog_data.operand[i],
3495                                         recog_data.operand[j]))
3496                   /* Is it altered by storing the earlyclobber operand?  */
3497                   && !immune_p (recog_data.operand[j], recog_data.operand[i],
3498                                 early_data))
3499                 {
3500                   /* If the output is in a single-reg class,
3501                      it's costly to reload it, so reload the input instead.  */
3502                   if (reg_class_size[this_alternative[i]] == 1
3503                       && (GET_CODE (recog_data.operand[j]) == REG
3504                           || GET_CODE (recog_data.operand[j]) == SUBREG))
3505                     {
3506                       losers++;
3507                       this_alternative_win[j] = 0;
3508                       this_alternative_match_win[j] = 0;
3509                     }
3510                   else
3511                     break;
3512                 }
3513             /* If an earlyclobber operand conflicts with something,
3514                it must be reloaded, so request this and count the cost.  */
3515             if (j != noperands)
3516               {
3517                 losers++;
3518                 this_alternative_win[i] = 0;
3519                 this_alternative_match_win[j] = 0;
3520                 for (j = 0; j < noperands; j++)
3521                   if (this_alternative_matches[j] == i
3522                       && this_alternative_match_win[j])
3523                     {
3524                       this_alternative_win[j] = 0;
3525                       this_alternative_match_win[j] = 0;
3526                       losers++;
3527                     }
3528               }
3529           }
3530
3531       /* If one alternative accepts all the operands, no reload required,
3532          choose that alternative; don't consider the remaining ones.  */
3533       if (losers == 0)
3534         {
3535           /* Unswap these so that they are never swapped at `finish'.  */
3536           if (commutative >= 0)
3537             {
3538               recog_data.operand[commutative] = substed_operand[commutative];
3539               recog_data.operand[commutative + 1]
3540                 = substed_operand[commutative + 1];
3541             }
3542           for (i = 0; i < noperands; i++)
3543             {
3544               goal_alternative_win[i] = this_alternative_win[i];
3545               goal_alternative_match_win[i] = this_alternative_match_win[i];
3546               goal_alternative[i] = this_alternative[i];
3547               goal_alternative_offmemok[i] = this_alternative_offmemok[i];
3548               goal_alternative_matches[i] = this_alternative_matches[i];
3549               goal_alternative_earlyclobber[i]
3550                 = this_alternative_earlyclobber[i];
3551             }
3552           goal_alternative_number = this_alternative_number;
3553           goal_alternative_swapped = swapped;
3554           goal_earlyclobber = this_earlyclobber;
3555           goto finish;
3556         }
3557
3558       /* REJECT, set by the ! and ? constraint characters and when a register
3559          would be reloaded into a non-preferred class, discourages the use of
3560          this alternative for a reload goal.  REJECT is incremented by six
3561          for each ? and two for each non-preferred class.  */
3562       losers = losers * 6 + reject;
3563
3564       /* If this alternative can be made to work by reloading,
3565          and it needs less reloading than the others checked so far,
3566          record it as the chosen goal for reloading.  */
3567       if (! bad && best > losers)
3568         {
3569           for (i = 0; i < noperands; i++)
3570             {
3571               goal_alternative[i] = this_alternative[i];
3572               goal_alternative_win[i] = this_alternative_win[i];
3573               goal_alternative_match_win[i] = this_alternative_match_win[i];
3574               goal_alternative_offmemok[i] = this_alternative_offmemok[i];
3575               goal_alternative_matches[i] = this_alternative_matches[i];
3576               goal_alternative_earlyclobber[i]
3577                 = this_alternative_earlyclobber[i];
3578             }
3579           goal_alternative_swapped = swapped;
3580           best = losers;
3581           goal_alternative_number = this_alternative_number;
3582           goal_earlyclobber = this_earlyclobber;
3583         }
3584     }
3585
3586   /* If insn is commutative (it's safe to exchange a certain pair of operands)
3587      then we need to try each alternative twice,
3588      the second time matching those two operands
3589      as if we had exchanged them.
3590      To do this, really exchange them in operands.
3591
3592      If we have just tried the alternatives the second time,
3593      return operands to normal and drop through.  */
3594
3595   if (commutative >= 0)
3596     {
3597       swapped = !swapped;
3598       if (swapped)
3599         {
3600           enum reg_class tclass;
3601           int t;
3602
3603           recog_data.operand[commutative] = substed_operand[commutative + 1];
3604           recog_data.operand[commutative + 1] = substed_operand[commutative];
3605           /* Swap the duplicates too.  */
3606           for (i = 0; i < recog_data.n_dups; i++)
3607             if (recog_data.dup_num[i] == commutative
3608                 || recog_data.dup_num[i] == commutative + 1)
3609               *recog_data.dup_loc[i]
3610                  = recog_data.operand[(int) recog_data.dup_num[i]];
3611
3612           tclass = preferred_class[commutative];
3613           preferred_class[commutative] = preferred_class[commutative + 1];
3614           preferred_class[commutative + 1] = tclass;
3615
3616           t = pref_or_nothing[commutative];
3617           pref_or_nothing[commutative] = pref_or_nothing[commutative + 1];
3618           pref_or_nothing[commutative + 1] = t;
3619
3620           memcpy (constraints, recog_data.constraints,
3621                   noperands * sizeof (char *));
3622           goto try_swapped;
3623         }
3624       else
3625         {
3626           recog_data.operand[commutative] = substed_operand[commutative];
3627           recog_data.operand[commutative + 1]
3628             = substed_operand[commutative + 1];
3629           /* Unswap the duplicates too.  */
3630           for (i = 0; i < recog_data.n_dups; i++)
3631             if (recog_data.dup_num[i] == commutative
3632                 || recog_data.dup_num[i] == commutative + 1)
3633               *recog_data.dup_loc[i]
3634                  = recog_data.operand[(int) recog_data.dup_num[i]];
3635         }
3636     }
3637
3638   /* The operands don't meet the constraints.
3639      goal_alternative describes the alternative
3640      that we could reach by reloading the fewest operands.
3641      Reload so as to fit it.  */
3642
3643   if (best == MAX_RECOG_OPERANDS * 2 + 600)
3644     {
3645       /* No alternative works with reloads??  */
3646       if (insn_code_number >= 0)
3647         fatal_insn ("unable to generate reloads for:", insn);
3648       error_for_asm (insn, "inconsistent operand constraints in an `asm'");
3649       /* Avoid further trouble with this insn.  */
3650       PATTERN (insn) = gen_rtx_USE (VOIDmode, const0_rtx);
3651       n_reloads = 0;
3652       return 0;
3653     }
3654
3655   /* Jump to `finish' from above if all operands are valid already.
3656      In that case, goal_alternative_win is all 1.  */
3657  finish:
3658
3659   /* Right now, for any pair of operands I and J that are required to match,
3660      with I < J,
3661      goal_alternative_matches[J] is I.
3662      Set up goal_alternative_matched as the inverse function:
3663      goal_alternative_matched[I] = J.  */
3664
3665   for (i = 0; i < noperands; i++)
3666     goal_alternative_matched[i] = -1;
3667
3668   for (i = 0; i < noperands; i++)
3669     if (! goal_alternative_win[i]
3670         && goal_alternative_matches[i] >= 0)
3671       goal_alternative_matched[goal_alternative_matches[i]] = i;
3672
3673   for (i = 0; i < noperands; i++)
3674     goal_alternative_win[i] |= goal_alternative_match_win[i];
3675
3676   /* If the best alternative is with operands 1 and 2 swapped,
3677      consider them swapped before reporting the reloads.  Update the
3678      operand numbers of any reloads already pushed.  */
3679
3680   if (goal_alternative_swapped)
3681     {
3682       rtx tem;
3683
3684       tem = substed_operand[commutative];
3685       substed_operand[commutative] = substed_operand[commutative + 1];
3686       substed_operand[commutative + 1] = tem;
3687       tem = recog_data.operand[commutative];
3688       recog_data.operand[commutative] = recog_data.operand[commutative + 1];
3689       recog_data.operand[commutative + 1] = tem;
3690       tem = *recog_data.operand_loc[commutative];
3691       *recog_data.operand_loc[commutative]
3692         = *recog_data.operand_loc[commutative + 1];
3693       *recog_data.operand_loc[commutative + 1] = tem;
3694
3695       for (i = 0; i < n_reloads; i++)
3696         {
3697           if (rld[i].opnum == commutative)
3698             rld[i].opnum = commutative + 1;
3699           else if (rld[i].opnum == commutative + 1)
3700             rld[i].opnum = commutative;
3701         }
3702     }
3703
3704   for (i = 0; i < noperands; i++)
3705     {
3706       operand_reloadnum[i] = -1;
3707
3708       /* If this is an earlyclobber operand, we need to widen the scope.
3709          The reload must remain valid from the start of the insn being
3710          reloaded until after the operand is stored into its destination.
3711          We approximate this with RELOAD_OTHER even though we know that we
3712          do not conflict with RELOAD_FOR_INPUT_ADDRESS reloads.
3713
3714          One special case that is worth checking is when we have an
3715          output that is earlyclobber but isn't used past the insn (typically
3716          a SCRATCH).  In this case, we only need have the reload live
3717          through the insn itself, but not for any of our input or output
3718          reloads.
3719          But we must not accidentally narrow the scope of an existing
3720          RELOAD_OTHER reload - leave these alone.
3721
3722          In any case, anything needed to address this operand can remain
3723          however they were previously categorized.  */
3724
3725       if (goal_alternative_earlyclobber[i] && operand_type[i] != RELOAD_OTHER)
3726         operand_type[i]
3727           = (find_reg_note (insn, REG_UNUSED, recog_data.operand[i])
3728              ? RELOAD_FOR_INSN : RELOAD_OTHER);
3729     }
3730
3731   /* Any constants that aren't allowed and can't be reloaded
3732      into registers are here changed into memory references.  */
3733   for (i = 0; i < noperands; i++)
3734     if (! goal_alternative_win[i]
3735         && CONSTANT_P (recog_data.operand[i])
3736         /* force_const_mem does not accept HIGH.  */
3737         && GET_CODE (recog_data.operand[i]) != HIGH
3738         && ((PREFERRED_RELOAD_CLASS (recog_data.operand[i],
3739                                      (enum reg_class) goal_alternative[i])
3740              == NO_REGS)
3741             || no_input_reloads)
3742         && operand_mode[i] != VOIDmode)
3743       {
3744         substed_operand[i] = recog_data.operand[i]
3745           = find_reloads_toplev (force_const_mem (operand_mode[i],
3746                                                   recog_data.operand[i]),
3747                                  i, address_type[i], ind_levels, 0, insn,
3748                                  NULL);
3749         if (alternative_allows_memconst (recog_data.constraints[i],
3750                                          goal_alternative_number))
3751           goal_alternative_win[i] = 1;
3752       }
3753
3754   /* Record the values of the earlyclobber operands for the caller.  */
3755   if (goal_earlyclobber)
3756     for (i = 0; i < noperands; i++)
3757       if (goal_alternative_earlyclobber[i])
3758         reload_earlyclobbers[n_earlyclobbers++] = recog_data.operand[i];
3759
3760   /* Now record reloads for all the operands that need them.  */
3761   for (i = 0; i < noperands; i++)
3762     if (! goal_alternative_win[i])
3763       {
3764         /* Operands that match previous ones have already been handled.  */
3765         if (goal_alternative_matches[i] >= 0)
3766           ;
3767         /* Handle an operand with a nonoffsettable address
3768            appearing where an offsettable address will do
3769            by reloading the address into a base register.
3770
3771            ??? We can also do this when the operand is a register and
3772            reg_equiv_mem is not offsettable, but this is a bit tricky,
3773            so we don't bother with it.  It may not be worth doing.  */
3774         else if (goal_alternative_matched[i] == -1
3775                  && goal_alternative_offmemok[i]
3776                  && GET_CODE (recog_data.operand[i]) == MEM)
3777           {
3778             operand_reloadnum[i]
3779               = push_reload (XEXP (recog_data.operand[i], 0), NULL_RTX,
3780                              &XEXP (recog_data.operand[i], 0), (rtx*) 0,
3781                              MODE_BASE_REG_CLASS (VOIDmode),
3782                              GET_MODE (XEXP (recog_data.operand[i], 0)),
3783                              VOIDmode, 0, 0, i, RELOAD_FOR_INPUT);
3784             rld[operand_reloadnum[i]].inc
3785               = GET_MODE_SIZE (GET_MODE (recog_data.operand[i]));
3786
3787             /* If this operand is an output, we will have made any
3788                reloads for its address as RELOAD_FOR_OUTPUT_ADDRESS, but
3789                now we are treating part of the operand as an input, so
3790                we must change these to RELOAD_FOR_INPUT_ADDRESS.  */
3791
3792             if (modified[i] == RELOAD_WRITE)
3793               {
3794                 for (j = 0; j < n_reloads; j++)
3795                   {
3796                     if (rld[j].opnum == i)
3797                       {
3798                         if (rld[j].when_needed == RELOAD_FOR_OUTPUT_ADDRESS)
3799                           rld[j].when_needed = RELOAD_FOR_INPUT_ADDRESS;
3800                         else if (rld[j].when_needed
3801                                  == RELOAD_FOR_OUTADDR_ADDRESS)
3802                           rld[j].when_needed = RELOAD_FOR_INPADDR_ADDRESS;
3803                       }
3804                   }
3805               }
3806           }
3807         else if (goal_alternative_matched[i] == -1)
3808           {
3809             operand_reloadnum[i]
3810               = push_reload ((modified[i] != RELOAD_WRITE
3811                               ? recog_data.operand[i] : 0),
3812                              (modified[i] != RELOAD_READ
3813                               ? recog_data.operand[i] : 0),
3814                              (modified[i] != RELOAD_WRITE
3815                               ? recog_data.operand_loc[i] : 0),
3816                              (modified[i] != RELOAD_READ
3817                               ? recog_data.operand_loc[i] : 0),
3818                              (enum reg_class) goal_alternative[i],
3819                              (modified[i] == RELOAD_WRITE
3820                               ? VOIDmode : operand_mode[i]),
3821                              (modified[i] == RELOAD_READ
3822                               ? VOIDmode : operand_mode[i]),
3823                              (insn_code_number < 0 ? 0
3824                               : insn_data[insn_code_number].operand[i].strict_low),
3825                              0, i, operand_type[i]);
3826           }
3827         /* In a matching pair of operands, one must be input only
3828            and the other must be output only.
3829            Pass the input operand as IN and the other as OUT.  */
3830         else if (modified[i] == RELOAD_READ
3831                  && modified[goal_alternative_matched[i]] == RELOAD_WRITE)
3832           {
3833             operand_reloadnum[i]
3834               = push_reload (recog_data.operand[i],
3835                              recog_data.operand[goal_alternative_matched[i]],
3836                              recog_data.operand_loc[i],
3837                              recog_data.operand_loc[goal_alternative_matched[i]],
3838                              (enum reg_class) goal_alternative[i],
3839                              operand_mode[i],
3840                              operand_mode[goal_alternative_matched[i]],
3841                              0, 0, i, RELOAD_OTHER);
3842             operand_reloadnum[goal_alternative_matched[i]] = output_reloadnum;
3843           }
3844         else if (modified[i] == RELOAD_WRITE
3845                  && modified[goal_alternative_matched[i]] == RELOAD_READ)
3846           {
3847             operand_reloadnum[goal_alternative_matched[i]]
3848               = push_reload (recog_data.operand[goal_alternative_matched[i]],
3849                              recog_data.operand[i],
3850                              recog_data.operand_loc[goal_alternative_matched[i]],
3851                              recog_data.operand_loc[i],
3852                              (enum reg_class) goal_alternative[i],
3853                              operand_mode[goal_alternative_matched[i]],
3854                              operand_mode[i],
3855                              0, 0, i, RELOAD_OTHER);
3856             operand_reloadnum[i] = output_reloadnum;
3857           }
3858         else if (insn_code_number >= 0)
3859           abort ();
3860         else
3861           {
3862             error_for_asm (insn, "inconsistent operand constraints in an `asm'");
3863             /* Avoid further trouble with this insn.  */
3864             PATTERN (insn) = gen_rtx_USE (VOIDmode, const0_rtx);
3865             n_reloads = 0;
3866             return 0;
3867           }
3868       }
3869     else if (goal_alternative_matched[i] < 0
3870              && goal_alternative_matches[i] < 0
3871              && !address_operand_reloaded[i]
3872              && optimize)
3873       {
3874         /* For each non-matching operand that's a MEM or a pseudo-register
3875            that didn't get a hard register, make an optional reload.
3876            This may get done even if the insn needs no reloads otherwise.  */
3877
3878         rtx operand = recog_data.operand[i];
3879
3880         while (GET_CODE (operand) == SUBREG)
3881           operand = SUBREG_REG (operand);
3882         if ((GET_CODE (operand) == MEM
3883              || (GET_CODE (operand) == REG
3884                  && REGNO (operand) >= FIRST_PSEUDO_REGISTER))
3885             /* If this is only for an output, the optional reload would not
3886                actually cause us to use a register now, just note that
3887                something is stored here.  */
3888             && ((enum reg_class) goal_alternative[i] != NO_REGS
3889                 || modified[i] == RELOAD_WRITE)
3890             && ! no_input_reloads
3891             /* An optional output reload might allow to delete INSN later.
3892                We mustn't make in-out reloads on insns that are not permitted
3893                output reloads.
3894                If this is an asm, we can't delete it; we must not even call
3895                push_reload for an optional output reload in this case,
3896                because we can't be sure that the constraint allows a register,
3897                and push_reload verifies the constraints for asms.  */
3898             && (modified[i] == RELOAD_READ
3899                 || (! no_output_reloads && ! this_insn_is_asm)))
3900           operand_reloadnum[i]
3901             = push_reload ((modified[i] != RELOAD_WRITE
3902                             ? recog_data.operand[i] : 0),
3903                            (modified[i] != RELOAD_READ
3904                             ? recog_data.operand[i] : 0),
3905                            (modified[i] != RELOAD_WRITE
3906                             ? recog_data.operand_loc[i] : 0),
3907                            (modified[i] != RELOAD_READ
3908                             ? recog_data.operand_loc[i] : 0),
3909                            (enum reg_class) goal_alternative[i],
3910                            (modified[i] == RELOAD_WRITE
3911                             ? VOIDmode : operand_mode[i]),
3912                            (modified[i] == RELOAD_READ
3913                             ? VOIDmode : operand_mode[i]),
3914                            (insn_code_number < 0 ? 0
3915                             : insn_data[insn_code_number].operand[i].strict_low),
3916                            1, i, operand_type[i]);
3917         /* If a memory reference remains (either as a MEM or a pseudo that
3918            did not get a hard register), yet we can't make an optional
3919            reload, check if this is actually a pseudo register reference;
3920            we then need to emit a USE and/or a CLOBBER so that reload
3921            inheritance will do the right thing.  */
3922         else if (replace
3923                  && (GET_CODE (operand) == MEM
3924                      || (GET_CODE (operand) == REG
3925                          && REGNO (operand) >= FIRST_PSEUDO_REGISTER
3926                          && reg_renumber [REGNO (operand)] < 0)))
3927           {
3928             operand = *recog_data.operand_loc[i];
3929
3930             while (GET_CODE (operand) == SUBREG)
3931               operand = SUBREG_REG (operand);
3932             if (GET_CODE (operand) == REG)
3933               {
3934                 if (modified[i] != RELOAD_WRITE)
3935                   /* We mark the USE with QImode so that we recognize
3936                      it as one that can be safely deleted at the end
3937                      of reload.  */
3938                   PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode, operand),
3939                                               insn), QImode);
3940                 if (modified[i] != RELOAD_READ)
3941                   emit_insn_after (gen_rtx_CLOBBER (VOIDmode, operand), insn);
3942               }
3943           }
3944       }
3945     else if (goal_alternative_matches[i] >= 0
3946              && goal_alternative_win[goal_alternative_matches[i]]
3947              && modified[i] == RELOAD_READ
3948              && modified[goal_alternative_matches[i]] == RELOAD_WRITE
3949              && ! no_input_reloads && ! no_output_reloads
3950              && optimize)
3951       {
3952         /* Similarly, make an optional reload for a pair of matching
3953            objects that are in MEM or a pseudo that didn't get a hard reg.  */
3954
3955         rtx operand = recog_data.operand[i];
3956
3957         while (GET_CODE (operand) == SUBREG)
3958           operand = SUBREG_REG (operand);
3959         if ((GET_CODE (operand) == MEM
3960              || (GET_CODE (operand) == REG
3961                  && REGNO (operand) >= FIRST_PSEUDO_REGISTER))
3962             && ((enum reg_class) goal_alternative[goal_alternative_matches[i]]
3963                 != NO_REGS))
3964           operand_reloadnum[i] = operand_reloadnum[goal_alternative_matches[i]]
3965             = push_reload (recog_data.operand[goal_alternative_matches[i]],
3966                            recog_data.operand[i],
3967                            recog_data.operand_loc[goal_alternative_matches[i]],
3968                            recog_data.operand_loc[i],
3969                            (enum reg_class) goal_alternative[goal_alternative_matches[i]],
3970                            operand_mode[goal_alternative_matches[i]],
3971                            operand_mode[i],
3972                            0, 1, goal_alternative_matches[i], RELOAD_OTHER);
3973       }
3974
3975   /* Perform whatever substitutions on the operands we are supposed
3976      to make due to commutativity or replacement of registers
3977      with equivalent constants or memory slots.  */
3978
3979   for (i = 0; i < noperands; i++)
3980     {
3981       /* We only do this on the last pass through reload, because it is
3982          possible for some data (like reg_equiv_address) to be changed during
3983          later passes.  Moreover, we loose the opportunity to get a useful
3984          reload_{in,out}_reg when we do these replacements.  */
3985
3986       if (replace)
3987         {
3988           rtx substitution = substed_operand[i];
3989
3990           *recog_data.operand_loc[i] = substitution;
3991
3992           /* If we're replacing an operand with a LABEL_REF, we need
3993              to make sure that there's a REG_LABEL note attached to
3994              this instruction.  */
3995           if (GET_CODE (insn) != JUMP_INSN
3996               && GET_CODE (substitution) == LABEL_REF
3997               && !find_reg_note (insn, REG_LABEL, XEXP (substitution, 0)))
3998             REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_LABEL,
3999                                                   XEXP (substitution, 0),
4000                                                   REG_NOTES (insn));
4001         }
4002       else
4003         retval |= (substed_operand[i] != *recog_data.operand_loc[i]);
4004     }
4005
4006   /* If this insn pattern contains any MATCH_DUP's, make sure that
4007      they will be substituted if the operands they match are substituted.
4008      Also do now any substitutions we already did on the operands.
4009
4010      Don't do this if we aren't making replacements because we might be
4011      propagating things allocated by frame pointer elimination into places
4012      it doesn't expect.  */
4013
4014   if (insn_code_number >= 0 && replace)
4015     for (i = insn_data[insn_code_number].n_dups - 1; i >= 0; i--)
4016       {
4017         int opno = recog_data.dup_num[i];
4018         *recog_data.dup_loc[i] = *recog_data.operand_loc[opno];
4019         dup_replacements (recog_data.dup_loc[i], recog_data.operand_loc[opno]);
4020       }
4021
4022 #if 0
4023   /* This loses because reloading of prior insns can invalidate the equivalence
4024      (or at least find_equiv_reg isn't smart enough to find it any more),
4025      causing this insn to need more reload regs than it needed before.
4026      It may be too late to make the reload regs available.
4027      Now this optimization is done safely in choose_reload_regs.  */
4028
4029   /* For each reload of a reg into some other class of reg,
4030      search for an existing equivalent reg (same value now) in the right class.
4031      We can use it as long as we don't need to change its contents.  */
4032   for (i = 0; i < n_reloads; i++)
4033     if (rld[i].reg_rtx == 0
4034         && rld[i].in != 0
4035         && GET_CODE (rld[i].in) == REG
4036         && rld[i].out == 0)
4037       {
4038         rld[i].reg_rtx
4039           = find_equiv_reg (rld[i].in, insn, rld[i].class, -1,
4040                             static_reload_reg_p, 0, rld[i].inmode);
4041         /* Prevent generation of insn to load the value
4042            because the one we found already has the value.  */
4043         if (rld[i].reg_rtx)
4044           rld[i].in = rld[i].reg_rtx;
4045       }
4046 #endif
4047
4048   /* Perhaps an output reload can be combined with another
4049      to reduce needs by one.  */
4050   if (!goal_earlyclobber)
4051     combine_reloads ();
4052
4053   /* If we have a pair of reloads for parts of an address, they are reloading
4054      the same object, the operands themselves were not reloaded, and they
4055      are for two operands that are supposed to match, merge the reloads and
4056      change the type of the surviving reload to RELOAD_FOR_OPERAND_ADDRESS.  */
4057
4058   for (i = 0; i < n_reloads; i++)
4059     {
4060       int k;
4061
4062       for (j = i + 1; j < n_reloads; j++)
4063         if ((rld[i].when_needed == RELOAD_FOR_INPUT_ADDRESS
4064              || rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS
4065              || rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS
4066              || rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
4067             && (rld[j].when_needed == RELOAD_FOR_INPUT_ADDRESS
4068                 || rld[j].when_needed == RELOAD_FOR_OUTPUT_ADDRESS
4069                 || rld[j].when_needed == RELOAD_FOR_INPADDR_ADDRESS
4070                 || rld[j].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
4071             && rtx_equal_p (rld[i].in, rld[j].in)
4072             && (operand_reloadnum[rld[i].opnum] < 0
4073                 || rld[operand_reloadnum[rld[i].opnum]].optional)
4074             && (operand_reloadnum[rld[j].opnum] < 0
4075                 || rld[operand_reloadnum[rld[j].opnum]].optional)
4076             && (goal_alternative_matches[rld[i].opnum] == rld[j].opnum
4077                 || (goal_alternative_matches[rld[j].opnum]
4078                     == rld[i].opnum)))
4079           {
4080             for (k = 0; k < n_replacements; k++)
4081               if (replacements[k].what == j)
4082                 replacements[k].what = i;
4083
4084             if (rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS
4085                 || rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
4086               rld[i].when_needed = RELOAD_FOR_OPADDR_ADDR;
4087             else
4088               rld[i].when_needed = RELOAD_FOR_OPERAND_ADDRESS;
4089             rld[j].in = 0;
4090           }
4091     }
4092
4093   /* Scan all the reloads and update their type.
4094      If a reload is for the address of an operand and we didn't reload
4095      that operand, change the type.  Similarly, change the operand number
4096      of a reload when two operands match.  If a reload is optional, treat it
4097      as though the operand isn't reloaded.
4098
4099      ??? This latter case is somewhat odd because if we do the optional
4100      reload, it means the object is hanging around.  Thus we need only
4101      do the address reload if the optional reload was NOT done.
4102
4103      Change secondary reloads to be the address type of their operand, not
4104      the normal type.
4105
4106      If an operand's reload is now RELOAD_OTHER, change any
4107      RELOAD_FOR_INPUT_ADDRESS reloads of that operand to
4108      RELOAD_FOR_OTHER_ADDRESS.  */
4109
4110   for (i = 0; i < n_reloads; i++)
4111     {
4112       if (rld[i].secondary_p
4113           && rld[i].when_needed == operand_type[rld[i].opnum])
4114         rld[i].when_needed = address_type[rld[i].opnum];
4115
4116       if ((rld[i].when_needed == RELOAD_FOR_INPUT_ADDRESS
4117            || rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS
4118            || rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS
4119            || rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
4120           && (operand_reloadnum[rld[i].opnum] < 0
4121               || rld[operand_reloadnum[rld[i].opnum]].optional))
4122         {
4123           /* If we have a secondary reload to go along with this reload,
4124              change its type to RELOAD_FOR_OPADDR_ADDR.  */
4125
4126           if ((rld[i].when_needed == RELOAD_FOR_INPUT_ADDRESS
4127                || rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS)
4128               && rld[i].secondary_in_reload != -1)
4129             {
4130               int secondary_in_reload = rld[i].secondary_in_reload;
4131
4132               rld[secondary_in_reload].when_needed = RELOAD_FOR_OPADDR_ADDR;
4133
4134               /* If there's a tertiary reload we have to change it also.  */
4135               if (secondary_in_reload > 0
4136                   && rld[secondary_in_reload].secondary_in_reload != -1)
4137                 rld[rld[secondary_in_reload].secondary_in_reload].when_needed
4138                   = RELOAD_FOR_OPADDR_ADDR;
4139             }
4140
4141           if ((rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS
4142                || rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
4143               && rld[i].secondary_out_reload != -1)
4144             {
4145               int secondary_out_reload = rld[i].secondary_out_reload;
4146
4147               rld[secondary_out_reload].when_needed = RELOAD_FOR_OPADDR_ADDR;
4148
4149               /* If there's a tertiary reload we have to change it also.  */
4150               if (secondary_out_reload
4151                   && rld[secondary_out_reload].secondary_out_reload != -1)
4152                 rld[rld[secondary_out_reload].secondary_out_reload].when_needed
4153                   = RELOAD_FOR_OPADDR_ADDR;
4154             }
4155
4156           if (rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS
4157               || rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
4158             rld[i].when_needed = RELOAD_FOR_OPADDR_ADDR;
4159           else
4160             rld[i].when_needed = RELOAD_FOR_OPERAND_ADDRESS;
4161         }
4162
4163       if ((rld[i].when_needed == RELOAD_FOR_INPUT_ADDRESS
4164            || rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS)
4165           && operand_reloadnum[rld[i].opnum] >= 0
4166           && (rld[operand_reloadnum[rld[i].opnum]].when_needed
4167               == RELOAD_OTHER))
4168         rld[i].when_needed = RELOAD_FOR_OTHER_ADDRESS;
4169
4170       if (goal_alternative_matches[rld[i].opnum] >= 0)
4171         rld[i].opnum = goal_alternative_matches[rld[i].opnum];
4172     }
4173
4174   /* Scan all the reloads, and check for RELOAD_FOR_OPERAND_ADDRESS reloads.
4175      If we have more than one, then convert all RELOAD_FOR_OPADDR_ADDR
4176      reloads to RELOAD_FOR_OPERAND_ADDRESS reloads.
4177
4178      choose_reload_regs assumes that RELOAD_FOR_OPADDR_ADDR reloads never
4179      conflict with RELOAD_FOR_OPERAND_ADDRESS reloads.  This is true for a
4180      single pair of RELOAD_FOR_OPADDR_ADDR/RELOAD_FOR_OPERAND_ADDRESS reloads.
4181      However, if there is more than one RELOAD_FOR_OPERAND_ADDRESS reload,
4182      then a RELOAD_FOR_OPADDR_ADDR reload conflicts with all
4183      RELOAD_FOR_OPERAND_ADDRESS reloads other than the one that uses it.
4184      This is complicated by the fact that a single operand can have more
4185      than one RELOAD_FOR_OPERAND_ADDRESS reload.  It is very difficult to fix
4186      choose_reload_regs without affecting code quality, and cases that
4187      actually fail are extremely rare, so it turns out to be better to fix
4188      the problem here by not generating cases that choose_reload_regs will
4189      fail for.  */
4190   /* There is a similar problem with RELOAD_FOR_INPUT_ADDRESS /
4191      RELOAD_FOR_OUTPUT_ADDRESS when there is more than one of a kind for
4192      a single operand.
4193      We can reduce the register pressure by exploiting that a
4194      RELOAD_FOR_X_ADDR_ADDR that precedes all RELOAD_FOR_X_ADDRESS reloads
4195      does not conflict with any of them, if it is only used for the first of
4196      the RELOAD_FOR_X_ADDRESS reloads.  */
4197   {
4198     int first_op_addr_num = -2;
4199     int first_inpaddr_num[MAX_RECOG_OPERANDS];
4200     int first_outpaddr_num[MAX_RECOG_OPERANDS];
4201     int need_change = 0;
4202     /* We use last_op_addr_reload and the contents of the above arrays
4203        first as flags - -2 means no instance encountered, -1 means exactly
4204        one instance encountered.
4205        If more than one instance has been encountered, we store the reload
4206        number of the first reload of the kind in question; reload numbers
4207        are known to be non-negative.  */
4208     for (i = 0; i < noperands; i++)
4209       first_inpaddr_num[i] = first_outpaddr_num[i] = -2;
4210     for (i = n_reloads - 1; i >= 0; i--)
4211       {
4212         switch (rld[i].when_needed)
4213           {
4214           case RELOAD_FOR_OPERAND_ADDRESS:
4215             if (++first_op_addr_num >= 0)
4216               {
4217                 first_op_addr_num = i;
4218                 need_change = 1;
4219               }
4220             break;
4221           case RELOAD_FOR_INPUT_ADDRESS:
4222             if (++first_inpaddr_num[rld[i].opnum] >= 0)
4223               {
4224                 first_inpaddr_num[rld[i].opnum] = i;
4225                 need_change = 1;
4226               }
4227             break;
4228           case RELOAD_FOR_OUTPUT_ADDRESS:
4229             if (++first_outpaddr_num[rld[i].opnum] >= 0)
4230               {
4231                 first_outpaddr_num[rld[i].opnum] = i;
4232                 need_change = 1;
4233               }
4234             break;
4235           default:
4236             break;
4237           }
4238       }
4239
4240     if (need_change)
4241       {
4242         for (i = 0; i < n_reloads; i++)
4243           {
4244             int first_num;
4245             enum reload_type type;
4246
4247             switch (rld[i].when_needed)
4248               {
4249               case RELOAD_FOR_OPADDR_ADDR:
4250                 first_num = first_op_addr_num;
4251                 type = RELOAD_FOR_OPERAND_ADDRESS;
4252                 break;
4253               case RELOAD_FOR_INPADDR_ADDRESS:
4254                 first_num = first_inpaddr_num[rld[i].opnum];
4255                 type = RELOAD_FOR_INPUT_ADDRESS;
4256                 break;
4257               case RELOAD_FOR_OUTADDR_ADDRESS:
4258                 first_num = first_outpaddr_num[rld[i].opnum];
4259                 type = RELOAD_FOR_OUTPUT_ADDRESS;
4260                 break;
4261               default:
4262                 continue;
4263               }
4264             if (first_num < 0)
4265               continue;
4266             else if (i > first_num)
4267               rld[i].when_needed = type;
4268             else
4269               {
4270                 /* Check if the only TYPE reload that uses reload I is
4271                    reload FIRST_NUM.  */
4272                 for (j = n_reloads - 1; j > first_num; j--)
4273                   {
4274                     if (rld[j].when_needed == type
4275                         && (rld[i].secondary_p
4276                             ? rld[j].secondary_in_reload == i
4277                             : reg_mentioned_p (rld[i].in, rld[j].in)))
4278                       {
4279                         rld[i].when_needed = type;
4280                         break;
4281                       }
4282                   }
4283               }
4284           }
4285       }
4286   }
4287
4288   /* See if we have any reloads that are now allowed to be merged
4289      because we've changed when the reload is needed to
4290      RELOAD_FOR_OPERAND_ADDRESS or RELOAD_FOR_OTHER_ADDRESS.  Only
4291      check for the most common cases.  */
4292
4293   for (i = 0; i < n_reloads; i++)
4294     if (rld[i].in != 0 && rld[i].out == 0
4295         && (rld[i].when_needed == RELOAD_FOR_OPERAND_ADDRESS
4296             || rld[i].when_needed == RELOAD_FOR_OPADDR_ADDR
4297             || rld[i].when_needed == RELOAD_FOR_OTHER_ADDRESS))
4298       for (j = 0; j < n_reloads; j++)
4299         if (i != j && rld[j].in != 0 && rld[j].out == 0
4300             && rld[j].when_needed == rld[i].when_needed
4301             && MATCHES (rld[i].in, rld[j].in)
4302             && rld[i].class == rld[j].class
4303             && !rld[i].nocombine && !rld[j].nocombine
4304             && rld[i].reg_rtx == rld[j].reg_rtx)
4305           {
4306             rld[i].opnum = MIN (rld[i].opnum, rld[j].opnum);
4307             transfer_replacements (i, j);
4308             rld[j].in = 0;
4309           }
4310
4311 #ifdef HAVE_cc0
4312   /* If we made any reloads for addresses, see if they violate a
4313      "no input reloads" requirement for this insn.  But loads that we
4314      do after the insn (such as for output addresses) are fine.  */
4315   if (no_input_reloads)
4316     for (i = 0; i < n_reloads; i++)
4317       if (rld[i].in != 0
4318           && rld[i].when_needed != RELOAD_FOR_OUTADDR_ADDRESS
4319           && rld[i].when_needed != RELOAD_FOR_OUTPUT_ADDRESS)
4320         abort ();
4321 #endif
4322
4323   /* Compute reload_mode and reload_nregs.  */
4324   for (i = 0; i < n_reloads; i++)
4325     {
4326       rld[i].mode
4327         = (rld[i].inmode == VOIDmode
4328            || (GET_MODE_SIZE (rld[i].outmode)
4329                > GET_MODE_SIZE (rld[i].inmode)))
4330           ? rld[i].outmode : rld[i].inmode;
4331
4332       rld[i].nregs = CLASS_MAX_NREGS (rld[i].class, rld[i].mode);
4333     }
4334
4335   /* Special case a simple move with an input reload and a
4336      destination of a hard reg, if the hard reg is ok, use it.  */
4337   for (i = 0; i < n_reloads; i++)
4338     if (rld[i].when_needed == RELOAD_FOR_INPUT
4339         && GET_CODE (PATTERN (insn)) == SET
4340         && GET_CODE (SET_DEST (PATTERN (insn))) == REG
4341         && SET_SRC (PATTERN (insn)) == rld[i].in)
4342       {
4343         rtx dest = SET_DEST (PATTERN (insn));
4344         unsigned int regno = REGNO (dest);
4345
4346         if (regno < FIRST_PSEUDO_REGISTER
4347             && TEST_HARD_REG_BIT (reg_class_contents[rld[i].class], regno)
4348             && HARD_REGNO_MODE_OK (regno, rld[i].mode))
4349           rld[i].reg_rtx = dest;
4350       }
4351
4352   return retval;
4353 }
4354
4355 /* Return 1 if alternative number ALTNUM in constraint-string CONSTRAINT
4356    accepts a memory operand with constant address.  */
4357
4358 static int
4359 alternative_allows_memconst (constraint, altnum)
4360      const char *constraint;
4361      int altnum;
4362 {
4363   int c;
4364   /* Skip alternatives before the one requested.  */
4365   while (altnum > 0)
4366     {
4367       while (*constraint++ != ',');
4368       altnum--;
4369     }
4370   /* Scan the requested alternative for 'm' or 'o'.
4371      If one of them is present, this alternative accepts memory constants.  */
4372   for (; (c = *constraint) && c != ',' && c != '#';
4373        constraint += CONSTRAINT_LEN (c, constraint))
4374     if (c == 'm' || c == 'o' || EXTRA_MEMORY_CONSTRAINT (c, constraint))
4375       return 1;
4376   return 0;
4377 }
4378 \f
4379 /* Scan X for memory references and scan the addresses for reloading.
4380    Also checks for references to "constant" regs that we want to eliminate
4381    and replaces them with the values they stand for.
4382    We may alter X destructively if it contains a reference to such.
4383    If X is just a constant reg, we return the equivalent value
4384    instead of X.
4385
4386    IND_LEVELS says how many levels of indirect addressing this machine
4387    supports.
4388
4389    OPNUM and TYPE identify the purpose of the reload.
4390
4391    IS_SET_DEST is true if X is the destination of a SET, which is not
4392    appropriate to be replaced by a constant.
4393
4394    INSN, if nonzero, is the insn in which we do the reload.  It is used
4395    to determine if we may generate output reloads, and where to put USEs
4396    for pseudos that we have to replace with stack slots.
4397
4398    ADDRESS_RELOADED.  If nonzero, is a pointer to where we put the
4399    result of find_reloads_address.  */
4400
4401 static rtx
4402 find_reloads_toplev (x, opnum, type, ind_levels, is_set_dest, insn,
4403                      address_reloaded)
4404      rtx x;
4405      int opnum;
4406      enum reload_type type;
4407      int ind_levels;
4408      int is_set_dest;
4409      rtx insn;
4410      int *address_reloaded;
4411 {
4412   RTX_CODE code = GET_CODE (x);
4413
4414   const char *fmt = GET_RTX_FORMAT (code);
4415   int i;
4416   int copied;
4417
4418   if (code == REG)
4419     {
4420       /* This code is duplicated for speed in find_reloads.  */
4421       int regno = REGNO (x);
4422       if (reg_equiv_constant[regno] != 0 && !is_set_dest)
4423         x = reg_equiv_constant[regno];
4424 #if 0
4425       /*  This creates (subreg (mem...)) which would cause an unnecessary
4426           reload of the mem.  */
4427       else if (reg_equiv_mem[regno] != 0)
4428         x = reg_equiv_mem[regno];
4429 #endif
4430       else if (reg_equiv_memory_loc[regno]
4431                && (reg_equiv_address[regno] != 0 || num_not_at_initial_offset))
4432         {
4433           rtx mem = make_memloc (x, regno);
4434           if (reg_equiv_address[regno]
4435               || ! rtx_equal_p (mem, reg_equiv_mem[regno]))
4436             {
4437               /* If this is not a toplevel operand, find_reloads doesn't see
4438                  this substitution.  We have to emit a USE of the pseudo so
4439                  that delete_output_reload can see it.  */
4440               if (replace_reloads && recog_data.operand[opnum] != x)
4441                 /* We mark the USE with QImode so that we recognize it
4442                    as one that can be safely deleted at the end of
4443                    reload.  */
4444                 PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode, x), insn),
4445                           QImode);
4446               x = mem;
4447               i = find_reloads_address (GET_MODE (x), &x, XEXP (x, 0), &XEXP (x, 0),
4448                                         opnum, type, ind_levels, insn);
4449               if (address_reloaded)
4450                 *address_reloaded = i;
4451             }
4452         }
4453       return x;
4454     }
4455   if (code == MEM)
4456     {
4457       rtx tem = x;
4458
4459       i = find_reloads_address (GET_MODE (x), &tem, XEXP (x, 0), &XEXP (x, 0),
4460                                 opnum, type, ind_levels, insn);
4461       if (address_reloaded)
4462         *address_reloaded = i;
4463
4464       return tem;
4465     }
4466
4467   if (code == SUBREG && GET_CODE (SUBREG_REG (x)) == REG)
4468     {
4469       /* Check for SUBREG containing a REG that's equivalent to a constant.
4470          If the constant has a known value, truncate it right now.
4471          Similarly if we are extracting a single-word of a multi-word
4472          constant.  If the constant is symbolic, allow it to be substituted
4473          normally.  push_reload will strip the subreg later.  If the
4474          constant is VOIDmode, abort because we will lose the mode of
4475          the register (this should never happen because one of the cases
4476          above should handle it).  */
4477
4478       int regno = REGNO (SUBREG_REG (x));
4479       rtx tem;
4480
4481       if (subreg_lowpart_p (x)
4482           && regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
4483           && reg_equiv_constant[regno] != 0
4484           && (tem = gen_lowpart_common (GET_MODE (x),
4485                                         reg_equiv_constant[regno])) != 0)
4486         return tem;
4487
4488       if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
4489           && reg_equiv_constant[regno] != 0)
4490         {
4491           tem =
4492             simplify_gen_subreg (GET_MODE (x), reg_equiv_constant[regno],
4493                                  GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
4494           if (!tem)
4495             abort ();
4496           return tem;
4497         }
4498
4499       /* If the subreg contains a reg that will be converted to a mem,
4500          convert the subreg to a narrower memref now.
4501          Otherwise, we would get (subreg (mem ...) ...),
4502          which would force reload of the mem.
4503
4504          We also need to do this if there is an equivalent MEM that is
4505          not offsettable.  In that case, alter_subreg would produce an
4506          invalid address on big-endian machines.
4507
4508          For machines that extend byte loads, we must not reload using
4509          a wider mode if we have a paradoxical SUBREG.  find_reloads will
4510          force a reload in that case.  So we should not do anything here.  */
4511
4512       else if (regno >= FIRST_PSEUDO_REGISTER
4513 #ifdef LOAD_EXTEND_OP
4514                && (GET_MODE_SIZE (GET_MODE (x))
4515                    <= GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
4516 #endif
4517                && (reg_equiv_address[regno] != 0
4518                    || (reg_equiv_mem[regno] != 0
4519                        && (! strict_memory_address_p (GET_MODE (x),
4520                                                       XEXP (reg_equiv_mem[regno], 0))
4521                            || ! offsettable_memref_p (reg_equiv_mem[regno])
4522                            || num_not_at_initial_offset))))
4523         x = find_reloads_subreg_address (x, 1, opnum, type, ind_levels,
4524                                          insn);
4525     }
4526
4527   for (copied = 0, i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
4528     {
4529       if (fmt[i] == 'e')
4530         {
4531           rtx new_part = find_reloads_toplev (XEXP (x, i), opnum, type,
4532                                               ind_levels, is_set_dest, insn,
4533                                               address_reloaded);
4534           /* If we have replaced a reg with it's equivalent memory loc -
4535              that can still be handled here e.g. if it's in a paradoxical
4536              subreg - we must make the change in a copy, rather than using
4537              a destructive change.  This way, find_reloads can still elect
4538              not to do the change.  */
4539           if (new_part != XEXP (x, i) && ! CONSTANT_P (new_part) && ! copied)
4540             {
4541               x = shallow_copy_rtx (x);
4542               copied = 1;
4543             }
4544           XEXP (x, i) = new_part;
4545         }
4546     }
4547   return x;
4548 }
4549
4550 /* Return a mem ref for the memory equivalent of reg REGNO.
4551    This mem ref is not shared with anything.  */
4552
4553 static rtx
4554 make_memloc (ad, regno)
4555      rtx ad;
4556      int regno;
4557 {
4558   /* We must rerun eliminate_regs, in case the elimination
4559      offsets have changed.  */
4560   rtx tem
4561     = XEXP (eliminate_regs (reg_equiv_memory_loc[regno], 0, NULL_RTX), 0);
4562
4563   /* If TEM might contain a pseudo, we must copy it to avoid
4564      modifying it when we do the substitution for the reload.  */
4565   if (rtx_varies_p (tem, 0))
4566     tem = copy_rtx (tem);
4567
4568   tem = replace_equiv_address_nv (reg_equiv_memory_loc[regno], tem);
4569   tem = adjust_address_nv (tem, GET_MODE (ad), 0);
4570
4571   /* Copy the result if it's still the same as the equivalence, to avoid
4572      modifying it when we do the substitution for the reload.  */
4573   if (tem == reg_equiv_memory_loc[regno])
4574     tem = copy_rtx (tem);
4575   return tem;
4576 }
4577
4578 /* Returns true if AD could be turned into a valid memory reference
4579    to mode MODE by reloading the part pointed to by PART into a
4580    register.  */
4581
4582 static int
4583 maybe_memory_address_p (mode, ad, part)
4584      enum machine_mode mode;
4585      rtx ad;
4586      rtx *part;
4587 {
4588   int retv;
4589   rtx tem = *part;
4590   rtx reg = gen_rtx_REG (GET_MODE (tem), max_reg_num ());
4591
4592   *part = reg;
4593   retv = memory_address_p (mode, ad);
4594   *part = tem;
4595
4596   return retv;
4597 }
4598
4599 /* Record all reloads needed for handling memory address AD
4600    which appears in *LOC in a memory reference to mode MODE
4601    which itself is found in location  *MEMREFLOC.
4602    Note that we take shortcuts assuming that no multi-reg machine mode
4603    occurs as part of an address.
4604
4605    OPNUM and TYPE specify the purpose of this reload.
4606
4607    IND_LEVELS says how many levels of indirect addressing this machine
4608    supports.
4609
4610    INSN, if nonzero, is the insn in which we do the reload.  It is used
4611    to determine if we may generate output reloads, and where to put USEs
4612    for pseudos that we have to replace with stack slots.
4613
4614    Value is nonzero if this address is reloaded or replaced as a whole.
4615    This is interesting to the caller if the address is an autoincrement.
4616
4617    Note that there is no verification that the address will be valid after
4618    this routine does its work.  Instead, we rely on the fact that the address
4619    was valid when reload started.  So we need only undo things that reload
4620    could have broken.  These are wrong register types, pseudos not allocated
4621    to a hard register, and frame pointer elimination.  */
4622
4623 static int
4624 find_reloads_address (mode, memrefloc, ad, loc, opnum, type, ind_levels, insn)
4625      enum machine_mode mode;
4626      rtx *memrefloc;
4627      rtx ad;
4628      rtx *loc;
4629      int opnum;
4630      enum reload_type type;
4631      int ind_levels;
4632      rtx insn;
4633 {
4634   int regno;
4635   int removed_and = 0;
4636   rtx tem;
4637
4638   /* If the address is a register, see if it is a legitimate address and
4639      reload if not.  We first handle the cases where we need not reload
4640      or where we must reload in a non-standard way.  */
4641
4642   if (GET_CODE (ad) == REG)
4643     {
4644       regno = REGNO (ad);
4645
4646       /* If the register is equivalent to an invariant expression, substitute
4647          the invariant, and eliminate any eliminable register references.  */
4648       tem = reg_equiv_constant[regno];
4649       if (tem != 0
4650           && (tem = eliminate_regs (tem, mode, insn))
4651           && strict_memory_address_p (mode, tem))
4652         {
4653           *loc = ad = tem;
4654           return 0;
4655         }
4656
4657       tem = reg_equiv_memory_loc[regno];
4658       if (tem != 0)
4659         {
4660           if (reg_equiv_address[regno] != 0 || num_not_at_initial_offset)
4661             {
4662               tem = make_memloc (ad, regno);
4663               if (! strict_memory_address_p (GET_MODE (tem), XEXP (tem, 0)))
4664                 {
4665                   find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
4666                                         &XEXP (tem, 0), opnum,
4667                                         ADDR_TYPE (type), ind_levels, insn);
4668                 }
4669               /* We can avoid a reload if the register's equivalent memory
4670                  expression is valid as an indirect memory address.
4671                  But not all addresses are valid in a mem used as an indirect
4672                  address: only reg or reg+constant.  */
4673
4674               if (ind_levels > 0
4675                   && strict_memory_address_p (mode, tem)
4676                   && (GET_CODE (XEXP (tem, 0)) == REG
4677                       || (GET_CODE (XEXP (tem, 0)) == PLUS
4678                           && GET_CODE (XEXP (XEXP (tem, 0), 0)) == REG
4679                           && CONSTANT_P (XEXP (XEXP (tem, 0), 1)))))
4680                 {
4681                   /* TEM is not the same as what we'll be replacing the
4682                      pseudo with after reload, put a USE in front of INSN
4683                      in the final reload pass.  */
4684                   if (replace_reloads
4685                       && num_not_at_initial_offset
4686                       && ! rtx_equal_p (tem, reg_equiv_mem[regno]))
4687                     {
4688                       *loc = tem;
4689                       /* We mark the USE with QImode so that we
4690                          recognize it as one that can be safely
4691                          deleted at the end of reload.  */
4692                       PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode, ad),
4693                                                   insn), QImode);
4694
4695                       /* This doesn't really count as replacing the address
4696                          as a whole, since it is still a memory access.  */
4697                     }
4698                   return 0;
4699                 }
4700               ad = tem;
4701             }
4702         }
4703
4704       /* The only remaining case where we can avoid a reload is if this is a
4705          hard register that is valid as a base register and which is not the
4706          subject of a CLOBBER in this insn.  */
4707
4708       else if (regno < FIRST_PSEUDO_REGISTER
4709                && REGNO_MODE_OK_FOR_BASE_P (regno, mode)
4710                && ! regno_clobbered_p (regno, this_insn, mode, 0))
4711         return 0;
4712
4713       /* If we do not have one of the cases above, we must do the reload.  */
4714       push_reload (ad, NULL_RTX, loc, (rtx*) 0, MODE_BASE_REG_CLASS (mode),
4715                    GET_MODE (ad), VOIDmode, 0, 0, opnum, type);
4716       return 1;
4717     }
4718
4719   if (strict_memory_address_p (mode, ad))
4720     {
4721       /* The address appears valid, so reloads are not needed.
4722          But the address may contain an eliminable register.
4723          This can happen because a machine with indirect addressing
4724          may consider a pseudo register by itself a valid address even when
4725          it has failed to get a hard reg.
4726          So do a tree-walk to find and eliminate all such regs.  */
4727
4728       /* But first quickly dispose of a common case.  */
4729       if (GET_CODE (ad) == PLUS
4730           && GET_CODE (XEXP (ad, 1)) == CONST_INT
4731           && GET_CODE (XEXP (ad, 0)) == REG
4732           && reg_equiv_constant[REGNO (XEXP (ad, 0))] == 0)
4733         return 0;
4734
4735       subst_reg_equivs_changed = 0;
4736       *loc = subst_reg_equivs (ad, insn);
4737
4738       if (! subst_reg_equivs_changed)
4739         return 0;
4740
4741       /* Check result for validity after substitution.  */
4742       if (strict_memory_address_p (mode, ad))
4743         return 0;
4744     }
4745
4746 #ifdef LEGITIMIZE_RELOAD_ADDRESS
4747   do
4748     {
4749       if (memrefloc)
4750         {
4751           LEGITIMIZE_RELOAD_ADDRESS (ad, GET_MODE (*memrefloc), opnum, type,
4752                                      ind_levels, win);
4753         }
4754       break;
4755     win:
4756       *memrefloc = copy_rtx (*memrefloc);
4757       XEXP (*memrefloc, 0) = ad;
4758       move_replacements (&ad, &XEXP (*memrefloc, 0));
4759       return 1;
4760     }
4761   while (0);
4762 #endif
4763
4764   /* The address is not valid.  We have to figure out why.  First see if
4765      we have an outer AND and remove it if so.  Then analyze what's inside.  */
4766
4767   if (GET_CODE (ad) == AND)
4768     {
4769       removed_and = 1;
4770       loc = &XEXP (ad, 0);
4771       ad = *loc;
4772     }
4773
4774   /* One possibility for why the address is invalid is that it is itself
4775      a MEM.  This can happen when the frame pointer is being eliminated, a
4776      pseudo is not allocated to a hard register, and the offset between the
4777      frame and stack pointers is not its initial value.  In that case the
4778      pseudo will have been replaced by a MEM referring to the
4779      stack pointer.  */
4780   if (GET_CODE (ad) == MEM)
4781     {
4782       /* First ensure that the address in this MEM is valid.  Then, unless
4783          indirect addresses are valid, reload the MEM into a register.  */
4784       tem = ad;
4785       find_reloads_address (GET_MODE (ad), &tem, XEXP (ad, 0), &XEXP (ad, 0),
4786                             opnum, ADDR_TYPE (type),
4787                             ind_levels == 0 ? 0 : ind_levels - 1, insn);
4788
4789       /* If tem was changed, then we must create a new memory reference to
4790          hold it and store it back into memrefloc.  */
4791       if (tem != ad && memrefloc)
4792         {
4793           *memrefloc = copy_rtx (*memrefloc);
4794           copy_replacements (tem, XEXP (*memrefloc, 0));
4795           loc = &XEXP (*memrefloc, 0);
4796           if (removed_and)
4797             loc = &XEXP (*loc, 0);
4798         }
4799
4800       /* Check similar cases as for indirect addresses as above except
4801          that we can allow pseudos and a MEM since they should have been
4802          taken care of above.  */
4803
4804       if (ind_levels == 0
4805           || (GET_CODE (XEXP (tem, 0)) == SYMBOL_REF && ! indirect_symref_ok)
4806           || GET_CODE (XEXP (tem, 0)) == MEM
4807           || ! (GET_CODE (XEXP (tem, 0)) == REG
4808                 || (GET_CODE (XEXP (tem, 0)) == PLUS
4809                     && GET_CODE (XEXP (XEXP (tem, 0), 0)) == REG
4810                     && GET_CODE (XEXP (XEXP (tem, 0), 1)) == CONST_INT)))
4811         {
4812           /* Must use TEM here, not AD, since it is the one that will
4813              have any subexpressions reloaded, if needed.  */
4814           push_reload (tem, NULL_RTX, loc, (rtx*) 0,
4815                        MODE_BASE_REG_CLASS (mode), GET_MODE (tem),
4816                        VOIDmode, 0,
4817                        0, opnum, type);
4818           return ! removed_and;
4819         }
4820       else
4821         return 0;
4822     }
4823
4824   /* If we have address of a stack slot but it's not valid because the
4825      displacement is too large, compute the sum in a register.
4826      Handle all base registers here, not just fp/ap/sp, because on some
4827      targets (namely SH) we can also get too large displacements from
4828      big-endian corrections.  */
4829   else if (GET_CODE (ad) == PLUS
4830            && GET_CODE (XEXP (ad, 0)) == REG
4831            && REGNO (XEXP (ad, 0)) < FIRST_PSEUDO_REGISTER
4832            && REG_MODE_OK_FOR_BASE_P (XEXP (ad, 0), mode)
4833            && GET_CODE (XEXP (ad, 1)) == CONST_INT)
4834     {
4835       /* Unshare the MEM rtx so we can safely alter it.  */
4836       if (memrefloc)
4837         {
4838           *memrefloc = copy_rtx (*memrefloc);
4839           loc = &XEXP (*memrefloc, 0);
4840           if (removed_and)
4841             loc = &XEXP (*loc, 0);
4842         }
4843
4844       if (double_reg_address_ok)
4845         {
4846           /* Unshare the sum as well.  */
4847           *loc = ad = copy_rtx (ad);
4848
4849           /* Reload the displacement into an index reg.
4850              We assume the frame pointer or arg pointer is a base reg.  */
4851           find_reloads_address_part (XEXP (ad, 1), &XEXP (ad, 1),
4852                                      INDEX_REG_CLASS, GET_MODE (ad), opnum,
4853                                      type, ind_levels);
4854           return 0;
4855         }
4856       else
4857         {
4858           /* If the sum of two regs is not necessarily valid,
4859              reload the sum into a base reg.
4860              That will at least work.  */
4861           find_reloads_address_part (ad, loc, MODE_BASE_REG_CLASS (mode),
4862                                      Pmode, opnum, type, ind_levels);
4863         }
4864       return ! removed_and;
4865     }
4866
4867   /* If we have an indexed stack slot, there are three possible reasons why
4868      it might be invalid: The index might need to be reloaded, the address
4869      might have been made by frame pointer elimination and hence have a
4870      constant out of range, or both reasons might apply.
4871
4872      We can easily check for an index needing reload, but even if that is the
4873      case, we might also have an invalid constant.  To avoid making the
4874      conservative assumption and requiring two reloads, we see if this address
4875      is valid when not interpreted strictly.  If it is, the only problem is
4876      that the index needs a reload and find_reloads_address_1 will take care
4877      of it.
4878
4879      Handle all base registers here, not just fp/ap/sp, because on some
4880      targets (namely Sparc) we can also get invalid addresses from preventive
4881      subreg big-endian corrections made by find_reloads_toplev.
4882
4883      If we decide to do something, it must be that `double_reg_address_ok'
4884      is true.  We generate a reload of the base register + constant and
4885      rework the sum so that the reload register will be added to the index.
4886      This is safe because we know the address isn't shared.
4887
4888      We check for the base register as both the first and second operand of
4889      the innermost PLUS.  */
4890
4891   else if (GET_CODE (ad) == PLUS && GET_CODE (XEXP (ad, 1)) == CONST_INT
4892            && GET_CODE (XEXP (ad, 0)) == PLUS
4893            && GET_CODE (XEXP (XEXP (ad, 0), 0)) == REG
4894            && REGNO (XEXP (XEXP (ad, 0), 0)) < FIRST_PSEUDO_REGISTER
4895            && REG_MODE_OK_FOR_BASE_P (XEXP (XEXP (ad, 0), 0), mode)
4896            && ! maybe_memory_address_p (mode, ad, &XEXP (XEXP (ad, 0), 1)))
4897     {
4898       *loc = ad = gen_rtx_PLUS (GET_MODE (ad),
4899                                 plus_constant (XEXP (XEXP (ad, 0), 0),
4900                                                INTVAL (XEXP (ad, 1))),
4901                                 XEXP (XEXP (ad, 0), 1));
4902       find_reloads_address_part (XEXP (ad, 0), &XEXP (ad, 0),
4903                                  MODE_BASE_REG_CLASS (mode),
4904                                  GET_MODE (ad), opnum, type, ind_levels);
4905       find_reloads_address_1 (mode, XEXP (ad, 1), 1, &XEXP (ad, 1), opnum,
4906                               type, 0, insn);
4907
4908       return 0;
4909     }
4910
4911   else if (GET_CODE (ad) == PLUS && GET_CODE (XEXP (ad, 1)) == CONST_INT
4912            && GET_CODE (XEXP (ad, 0)) == PLUS
4913            && GET_CODE (XEXP (XEXP (ad, 0), 1)) == REG
4914            && REGNO (XEXP (XEXP (ad, 0), 1)) < FIRST_PSEUDO_REGISTER
4915            && REG_MODE_OK_FOR_BASE_P (XEXP (XEXP (ad, 0), 1), mode)
4916            && ! maybe_memory_address_p (mode, ad, &XEXP (XEXP (ad, 0), 0)))
4917     {
4918       *loc = ad = gen_rtx_PLUS (GET_MODE (ad),
4919                                 XEXP (XEXP (ad, 0), 0),
4920                                 plus_constant (XEXP (XEXP (ad, 0), 1),
4921                                                INTVAL (XEXP (ad, 1))));
4922       find_reloads_address_part (XEXP (ad, 1), &XEXP (ad, 1),
4923                                  MODE_BASE_REG_CLASS (mode),
4924                                  GET_MODE (ad), opnum, type, ind_levels);
4925       find_reloads_address_1 (mode, XEXP (ad, 0), 1, &XEXP (ad, 0), opnum,
4926                               type, 0, insn);
4927
4928       return 0;
4929     }
4930
4931   /* See if address becomes valid when an eliminable register
4932      in a sum is replaced.  */
4933
4934   tem = ad;
4935   if (GET_CODE (ad) == PLUS)
4936     tem = subst_indexed_address (ad);
4937   if (tem != ad && strict_memory_address_p (mode, tem))
4938     {
4939       /* Ok, we win that way.  Replace any additional eliminable
4940          registers.  */
4941
4942       subst_reg_equivs_changed = 0;
4943       tem = subst_reg_equivs (tem, insn);
4944
4945       /* Make sure that didn't make the address invalid again.  */
4946
4947       if (! subst_reg_equivs_changed || strict_memory_address_p (mode, tem))
4948         {
4949           *loc = tem;
4950           return 0;
4951         }
4952     }
4953
4954   /* If constants aren't valid addresses, reload the constant address
4955      into a register.  */
4956   if (CONSTANT_P (ad) && ! strict_memory_address_p (mode, ad))
4957     {
4958       /* If AD is an address in the constant pool, the MEM rtx may be shared.
4959          Unshare it so we can safely alter it.  */
4960       if (memrefloc && GET_CODE (ad) == SYMBOL_REF
4961           && CONSTANT_POOL_ADDRESS_P (ad))
4962         {
4963           *memrefloc = copy_rtx (*memrefloc);
4964           loc = &XEXP (*memrefloc, 0);
4965           if (removed_and)
4966             loc = &XEXP (*loc, 0);
4967         }
4968
4969       find_reloads_address_part (ad, loc, MODE_BASE_REG_CLASS (mode),
4970                                  Pmode, opnum, type, ind_levels);
4971       return ! removed_and;
4972     }
4973
4974   return find_reloads_address_1 (mode, ad, 0, loc, opnum, type, ind_levels,
4975                                  insn);
4976 }
4977 \f
4978 /* Find all pseudo regs appearing in AD
4979    that are eliminable in favor of equivalent values
4980    and do not have hard regs; replace them by their equivalents.
4981    INSN, if nonzero, is the insn in which we do the reload.  We put USEs in
4982    front of it for pseudos that we have to replace with stack slots.  */
4983
4984 static rtx
4985 subst_reg_equivs (ad, insn)
4986      rtx ad;
4987      rtx insn;
4988 {
4989   RTX_CODE code = GET_CODE (ad);
4990   int i;
4991   const char *fmt;
4992
4993   switch (code)
4994     {
4995     case HIGH:
4996     case CONST_INT:
4997     case CONST:
4998     case CONST_DOUBLE:
4999     case CONST_VECTOR:
5000     case SYMBOL_REF:
5001     case LABEL_REF:
5002     case PC:
5003     case CC0:
5004       return ad;
5005
5006     case REG:
5007       {
5008         int regno = REGNO (ad);
5009
5010         if (reg_equiv_constant[regno] != 0)
5011           {
5012             subst_reg_equivs_changed = 1;
5013             return reg_equiv_constant[regno];
5014           }
5015         if (reg_equiv_memory_loc[regno] && num_not_at_initial_offset)
5016           {
5017             rtx mem = make_memloc (ad, regno);
5018             if (! rtx_equal_p (mem, reg_equiv_mem[regno]))
5019               {
5020                 subst_reg_equivs_changed = 1;
5021                 /* We mark the USE with QImode so that we recognize it
5022                    as one that can be safely deleted at the end of
5023                    reload.  */
5024                 PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode, ad), insn),
5025                           QImode);
5026                 return mem;
5027               }
5028           }
5029       }
5030       return ad;
5031
5032     case PLUS:
5033       /* Quickly dispose of a common case.  */
5034       if (XEXP (ad, 0) == frame_pointer_rtx
5035           && GET_CODE (XEXP (ad, 1)) == CONST_INT)
5036         return ad;
5037       break;
5038
5039     default:
5040       break;
5041     }
5042
5043   fmt = GET_RTX_FORMAT (code);
5044   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
5045     if (fmt[i] == 'e')
5046       XEXP (ad, i) = subst_reg_equivs (XEXP (ad, i), insn);
5047   return ad;
5048 }
5049 \f
5050 /* Compute the sum of X and Y, making canonicalizations assumed in an
5051    address, namely: sum constant integers, surround the sum of two
5052    constants with a CONST, put the constant as the second operand, and
5053    group the constant on the outermost sum.
5054
5055    This routine assumes both inputs are already in canonical form.  */
5056
5057 rtx
5058 form_sum (x, y)
5059      rtx x, y;
5060 {
5061   rtx tem;
5062   enum machine_mode mode = GET_MODE (x);
5063
5064   if (mode == VOIDmode)
5065     mode = GET_MODE (y);
5066
5067   if (mode == VOIDmode)
5068     mode = Pmode;
5069
5070   if (GET_CODE (x) == CONST_INT)
5071     return plus_constant (y, INTVAL (x));
5072   else if (GET_CODE (y) == CONST_INT)
5073     return plus_constant (x, INTVAL (y));
5074   else if (CONSTANT_P (x))
5075     tem = x, x = y, y = tem;
5076
5077   if (GET_CODE (x) == PLUS && CONSTANT_P (XEXP (x, 1)))
5078     return form_sum (XEXP (x, 0), form_sum (XEXP (x, 1), y));
5079
5080   /* Note that if the operands of Y are specified in the opposite
5081      order in the recursive calls below, infinite recursion will occur.  */
5082   if (GET_CODE (y) == PLUS && CONSTANT_P (XEXP (y, 1)))
5083     return form_sum (form_sum (x, XEXP (y, 0)), XEXP (y, 1));
5084
5085   /* If both constant, encapsulate sum.  Otherwise, just form sum.  A
5086      constant will have been placed second.  */
5087   if (CONSTANT_P (x) && CONSTANT_P (y))
5088     {
5089       if (GET_CODE (x) == CONST)
5090         x = XEXP (x, 0);
5091       if (GET_CODE (y) == CONST)
5092         y = XEXP (y, 0);
5093
5094       return gen_rtx_CONST (VOIDmode, gen_rtx_PLUS (mode, x, y));
5095     }
5096
5097   return gen_rtx_PLUS (mode, x, y);
5098 }
5099 \f
5100 /* If ADDR is a sum containing a pseudo register that should be
5101    replaced with a constant (from reg_equiv_constant),
5102    return the result of doing so, and also apply the associative
5103    law so that the result is more likely to be a valid address.
5104    (But it is not guaranteed to be one.)
5105
5106    Note that at most one register is replaced, even if more are
5107    replaceable.  Also, we try to put the result into a canonical form
5108    so it is more likely to be a valid address.
5109
5110    In all other cases, return ADDR.  */
5111
5112 static rtx
5113 subst_indexed_address (addr)
5114      rtx addr;
5115 {
5116   rtx op0 = 0, op1 = 0, op2 = 0;
5117   rtx tem;
5118   int regno;
5119
5120   if (GET_CODE (addr) == PLUS)
5121     {
5122       /* Try to find a register to replace.  */
5123       op0 = XEXP (addr, 0), op1 = XEXP (addr, 1), op2 = 0;
5124       if (GET_CODE (op0) == REG
5125           && (regno = REGNO (op0)) >= FIRST_PSEUDO_REGISTER
5126           && reg_renumber[regno] < 0
5127           && reg_equiv_constant[regno] != 0)
5128         op0 = reg_equiv_constant[regno];
5129       else if (GET_CODE (op1) == REG
5130                && (regno = REGNO (op1)) >= FIRST_PSEUDO_REGISTER
5131                && reg_renumber[regno] < 0
5132                && reg_equiv_constant[regno] != 0)
5133         op1 = reg_equiv_constant[regno];
5134       else if (GET_CODE (op0) == PLUS
5135                && (tem = subst_indexed_address (op0)) != op0)
5136         op0 = tem;
5137       else if (GET_CODE (op1) == PLUS
5138                && (tem = subst_indexed_address (op1)) != op1)
5139         op1 = tem;
5140       else
5141         return addr;
5142
5143       /* Pick out up to three things to add.  */
5144       if (GET_CODE (op1) == PLUS)
5145         op2 = XEXP (op1, 1), op1 = XEXP (op1, 0);
5146       else if (GET_CODE (op0) == PLUS)
5147         op2 = op1, op1 = XEXP (op0, 1), op0 = XEXP (op0, 0);
5148
5149       /* Compute the sum.  */
5150       if (op2 != 0)
5151         op1 = form_sum (op1, op2);
5152       if (op1 != 0)
5153         op0 = form_sum (op0, op1);
5154
5155       return op0;
5156     }
5157   return addr;
5158 }
5159 \f
5160 /* Update the REG_INC notes for an insn.  It updates all REG_INC
5161    notes for the instruction which refer to REGNO the to refer
5162    to the reload number.
5163
5164    INSN is the insn for which any REG_INC notes need updating.
5165
5166    REGNO is the register number which has been reloaded.
5167
5168    RELOADNUM is the reload number.  */
5169
5170 static void
5171 update_auto_inc_notes (insn, regno, reloadnum)
5172      rtx insn ATTRIBUTE_UNUSED;
5173      int regno ATTRIBUTE_UNUSED;
5174      int reloadnum ATTRIBUTE_UNUSED;
5175 {
5176 #ifdef AUTO_INC_DEC
5177   rtx link;
5178
5179   for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
5180     if (REG_NOTE_KIND (link) == REG_INC
5181         && (int) REGNO (XEXP (link, 0)) == regno)
5182       push_replacement (&XEXP (link, 0), reloadnum, VOIDmode);
5183 #endif
5184 }
5185 \f
5186 /* Record the pseudo registers we must reload into hard registers in a
5187    subexpression of a would-be memory address, X referring to a value
5188    in mode MODE.  (This function is not called if the address we find
5189    is strictly valid.)
5190
5191    CONTEXT = 1 means we are considering regs as index regs,
5192    = 0 means we are considering them as base regs.
5193
5194    OPNUM and TYPE specify the purpose of any reloads made.
5195
5196    IND_LEVELS says how many levels of indirect addressing are
5197    supported at this point in the address.
5198
5199    INSN, if nonzero, is the insn in which we do the reload.  It is used
5200    to determine if we may generate output reloads.
5201
5202    We return nonzero if X, as a whole, is reloaded or replaced.  */
5203
5204 /* Note that we take shortcuts assuming that no multi-reg machine mode
5205    occurs as part of an address.
5206    Also, this is not fully machine-customizable; it works for machines
5207    such as VAXen and 68000's and 32000's, but other possible machines
5208    could have addressing modes that this does not handle right.  */
5209
5210 static int
5211 find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
5212      enum machine_mode mode;
5213      rtx x;
5214      int context;
5215      rtx *loc;
5216      int opnum;
5217      enum reload_type type;
5218      int ind_levels;
5219      rtx insn;
5220 {
5221   RTX_CODE code = GET_CODE (x);
5222
5223   switch (code)
5224     {
5225     case PLUS:
5226       {
5227         rtx orig_op0 = XEXP (x, 0);
5228         rtx orig_op1 = XEXP (x, 1);
5229         RTX_CODE code0 = GET_CODE (orig_op0);
5230         RTX_CODE code1 = GET_CODE (orig_op1);
5231         rtx op0 = orig_op0;
5232         rtx op1 = orig_op1;
5233
5234         if (GET_CODE (op0) == SUBREG)
5235           {
5236             op0 = SUBREG_REG (op0);
5237             code0 = GET_CODE (op0);
5238             if (code0 == REG && REGNO (op0) < FIRST_PSEUDO_REGISTER)
5239               op0 = gen_rtx_REG (word_mode,
5240                                  (REGNO (op0) +
5241                                   subreg_regno_offset (REGNO (SUBREG_REG (orig_op0)),
5242                                                        GET_MODE (SUBREG_REG (orig_op0)),
5243                                                        SUBREG_BYTE (orig_op0),
5244                                                        GET_MODE (orig_op0))));
5245           }
5246
5247         if (GET_CODE (op1) == SUBREG)
5248           {
5249             op1 = SUBREG_REG (op1);
5250             code1 = GET_CODE (op1);
5251             if (code1 == REG && REGNO (op1) < FIRST_PSEUDO_REGISTER)
5252               /* ??? Why is this given op1's mode and above for
5253                  ??? op0 SUBREGs we use word_mode?  */
5254               op1 = gen_rtx_REG (GET_MODE (op1),
5255                                  (REGNO (op1) +
5256                                   subreg_regno_offset (REGNO (SUBREG_REG (orig_op1)),
5257                                                        GET_MODE (SUBREG_REG (orig_op1)),
5258                                                        SUBREG_BYTE (orig_op1),
5259                                                        GET_MODE (orig_op1))));
5260           }
5261         /* Plus in the index register may be created only as a result of
5262            register remateralization for expresion like &localvar*4.  Reload it.
5263            It may be possible to combine the displacement on the outer level,
5264            but it is probably not worthwhile to do so.  */
5265         if (context)
5266           {
5267             find_reloads_address (GET_MODE (x), loc, XEXP (x, 0), &XEXP (x, 0),
5268                                   opnum, ADDR_TYPE (type), ind_levels, insn);
5269             push_reload (*loc, NULL_RTX, loc, (rtx*) 0,
5270                          (context ? INDEX_REG_CLASS : MODE_BASE_REG_CLASS (mode)),
5271                          GET_MODE (x), VOIDmode, 0, 0, opnum, type);
5272             return 1;
5273           }
5274
5275         if (code0 == MULT || code0 == SIGN_EXTEND || code0 == TRUNCATE
5276             || code0 == ZERO_EXTEND || code1 == MEM)
5277           {
5278             find_reloads_address_1 (mode, orig_op0, 1, &XEXP (x, 0), opnum,
5279                                     type, ind_levels, insn);
5280             find_reloads_address_1 (mode, orig_op1, 0, &XEXP (x, 1), opnum,
5281                                     type, ind_levels, insn);
5282           }
5283
5284         else if (code1 == MULT || code1 == SIGN_EXTEND || code1 == TRUNCATE
5285                  || code1 == ZERO_EXTEND || code0 == MEM)
5286           {
5287             find_reloads_address_1 (mode, orig_op0, 0, &XEXP (x, 0), opnum,
5288                                     type, ind_levels, insn);
5289             find_reloads_address_1 (mode, orig_op1, 1, &XEXP (x, 1), opnum,
5290                                     type, ind_levels, insn);
5291           }
5292
5293         else if (code0 == CONST_INT || code0 == CONST
5294                  || code0 == SYMBOL_REF || code0 == LABEL_REF)
5295           find_reloads_address_1 (mode, orig_op1, 0, &XEXP (x, 1), opnum,
5296                                   type, ind_levels, insn);
5297
5298         else if (code1 == CONST_INT || code1 == CONST
5299                  || code1 == SYMBOL_REF || code1 == LABEL_REF)
5300           find_reloads_address_1 (mode, orig_op0, 0, &XEXP (x, 0), opnum,
5301                                   type, ind_levels, insn);
5302
5303         else if (code0 == REG && code1 == REG)
5304           {
5305             if (REG_OK_FOR_INDEX_P (op0)
5306                 && REG_MODE_OK_FOR_BASE_P (op1, mode))
5307               return 0;
5308             else if (REG_OK_FOR_INDEX_P (op1)
5309                      && REG_MODE_OK_FOR_BASE_P (op0, mode))
5310               return 0;
5311             else if (REG_MODE_OK_FOR_BASE_P (op1, mode))
5312               find_reloads_address_1 (mode, orig_op0, 1, &XEXP (x, 0), opnum,
5313                                       type, ind_levels, insn);
5314             else if (REG_MODE_OK_FOR_BASE_P (op0, mode))
5315               find_reloads_address_1 (mode, orig_op1, 1, &XEXP (x, 1), opnum,
5316                                       type, ind_levels, insn);
5317             else if (REG_OK_FOR_INDEX_P (op1))
5318               find_reloads_address_1 (mode, orig_op0, 0, &XEXP (x, 0), opnum,
5319                                       type, ind_levels, insn);
5320             else if (REG_OK_FOR_INDEX_P (op0))
5321               find_reloads_address_1 (mode, orig_op1, 0, &XEXP (x, 1), opnum,
5322                                       type, ind_levels, insn);
5323             else
5324               {
5325                 find_reloads_address_1 (mode, orig_op0, 1, &XEXP (x, 0), opnum,
5326                                         type, ind_levels, insn);
5327                 find_reloads_address_1 (mode, orig_op1, 0, &XEXP (x, 1), opnum,
5328                                         type, ind_levels, insn);
5329               }
5330           }
5331
5332         else if (code0 == REG)
5333           {
5334             find_reloads_address_1 (mode, orig_op0, 1, &XEXP (x, 0), opnum,
5335                                     type, ind_levels, insn);
5336             find_reloads_address_1 (mode, orig_op1, 0, &XEXP (x, 1), opnum,
5337                                     type, ind_levels, insn);
5338           }
5339
5340         else if (code1 == REG)
5341           {
5342             find_reloads_address_1 (mode, orig_op1, 1, &XEXP (x, 1), opnum,
5343                                     type, ind_levels, insn);
5344             find_reloads_address_1 (mode, orig_op0, 0, &XEXP (x, 0), opnum,
5345                                     type, ind_levels, insn);
5346           }
5347       }
5348
5349       return 0;
5350
5351     case POST_MODIFY:
5352     case PRE_MODIFY:
5353       {
5354         rtx op0 = XEXP (x, 0);
5355         rtx op1 = XEXP (x, 1);
5356
5357         if (GET_CODE (op1) != PLUS && GET_CODE (op1) != MINUS)
5358           return 0;
5359
5360         /* Currently, we only support {PRE,POST}_MODIFY constructs
5361            where a base register is {inc,dec}remented by the contents
5362            of another register or by a constant value.  Thus, these
5363            operands must match.  */
5364         if (op0 != XEXP (op1, 0))
5365           abort ();
5366
5367         /* Require index register (or constant).  Let's just handle the
5368            register case in the meantime... If the target allows
5369            auto-modify by a constant then we could try replacing a pseudo
5370            register with its equivalent constant where applicable.  */
5371         if (REG_P (XEXP (op1, 1)))
5372           if (!REGNO_OK_FOR_INDEX_P (REGNO (XEXP (op1, 1))))
5373             find_reloads_address_1 (mode, XEXP (op1, 1), 1, &XEXP (op1, 1),
5374                                     opnum, type, ind_levels, insn);
5375
5376         if (REG_P (XEXP (op1, 0)))
5377           {
5378             int regno = REGNO (XEXP (op1, 0));
5379             int reloadnum;
5380
5381             /* A register that is incremented cannot be constant!  */
5382             if (regno >= FIRST_PSEUDO_REGISTER
5383                 && reg_equiv_constant[regno] != 0)
5384               abort ();
5385
5386             /* Handle a register that is equivalent to a memory location
5387                which cannot be addressed directly.  */
5388             if (reg_equiv_memory_loc[regno] != 0
5389                 && (reg_equiv_address[regno] != 0
5390                     || num_not_at_initial_offset))
5391               {
5392                 rtx tem = make_memloc (XEXP (x, 0), regno);
5393
5394                 if (reg_equiv_address[regno]
5395                     || ! rtx_equal_p (tem, reg_equiv_mem[regno]))
5396                   {
5397                     /* First reload the memory location's address.
5398                        We can't use ADDR_TYPE (type) here, because we need to
5399                        write back the value after reading it, hence we actually
5400                        need two registers.  */
5401                     find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
5402                                           &XEXP (tem, 0), opnum,
5403                                           RELOAD_OTHER,
5404                                           ind_levels, insn);
5405
5406                     /* Then reload the memory location into a base
5407                        register.  */
5408                     reloadnum = push_reload (tem, tem, &XEXP (x, 0),
5409                                              &XEXP (op1, 0),
5410                                              MODE_BASE_REG_CLASS (mode),
5411                                              GET_MODE (x), GET_MODE (x), 0,
5412                                              0, opnum, RELOAD_OTHER);
5413
5414                     update_auto_inc_notes (this_insn, regno, reloadnum);
5415                     return 0;
5416                   }
5417               }
5418
5419             if (reg_renumber[regno] >= 0)
5420               regno = reg_renumber[regno];
5421
5422             /* We require a base register here...  */
5423             if (!REGNO_MODE_OK_FOR_BASE_P (regno, GET_MODE (x)))
5424               {
5425                 reloadnum = push_reload (XEXP (op1, 0), XEXP (x, 0),
5426                                          &XEXP (op1, 0), &XEXP (x, 0),
5427                                          MODE_BASE_REG_CLASS (mode),
5428                                          GET_MODE (x), GET_MODE (x), 0, 0,
5429                                          opnum, RELOAD_OTHER);
5430
5431                 update_auto_inc_notes (this_insn, regno, reloadnum);
5432                 return 0;
5433               }
5434           }
5435         else
5436           abort ();
5437       }
5438       return 0;
5439
5440     case POST_INC:
5441     case POST_DEC:
5442     case PRE_INC:
5443     case PRE_DEC:
5444       if (GET_CODE (XEXP (x, 0)) == REG)
5445         {
5446           int regno = REGNO (XEXP (x, 0));
5447           int value = 0;
5448           rtx x_orig = x;
5449
5450           /* A register that is incremented cannot be constant!  */
5451           if (regno >= FIRST_PSEUDO_REGISTER
5452               && reg_equiv_constant[regno] != 0)
5453             abort ();
5454
5455           /* Handle a register that is equivalent to a memory location
5456              which cannot be addressed directly.  */
5457           if (reg_equiv_memory_loc[regno] != 0
5458               && (reg_equiv_address[regno] != 0 || num_not_at_initial_offset))
5459             {
5460               rtx tem = make_memloc (XEXP (x, 0), regno);
5461               if (reg_equiv_address[regno]
5462                   || ! rtx_equal_p (tem, reg_equiv_mem[regno]))
5463                 {
5464                   /* First reload the memory location's address.
5465                      We can't use ADDR_TYPE (type) here, because we need to
5466                      write back the value after reading it, hence we actually
5467                      need two registers.  */
5468                   find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
5469                                         &XEXP (tem, 0), opnum, type,
5470                                         ind_levels, insn);
5471                   /* Put this inside a new increment-expression.  */
5472                   x = gen_rtx_fmt_e (GET_CODE (x), GET_MODE (x), tem);
5473                   /* Proceed to reload that, as if it contained a register.  */
5474                 }
5475             }
5476
5477           /* If we have a hard register that is ok as an index,
5478              don't make a reload.  If an autoincrement of a nice register
5479              isn't "valid", it must be that no autoincrement is "valid".
5480              If that is true and something made an autoincrement anyway,
5481              this must be a special context where one is allowed.
5482              (For example, a "push" instruction.)
5483              We can't improve this address, so leave it alone.  */
5484
5485           /* Otherwise, reload the autoincrement into a suitable hard reg
5486              and record how much to increment by.  */
5487
5488           if (reg_renumber[regno] >= 0)
5489             regno = reg_renumber[regno];
5490           if ((regno >= FIRST_PSEUDO_REGISTER
5491                || !(context ? REGNO_OK_FOR_INDEX_P (regno)
5492                     : REGNO_MODE_OK_FOR_BASE_P (regno, mode))))
5493             {
5494               int reloadnum;
5495
5496               /* If we can output the register afterwards, do so, this
5497                  saves the extra update.
5498                  We can do so if we have an INSN - i.e. no JUMP_INSN nor
5499                  CALL_INSN - and it does not set CC0.
5500                  But don't do this if we cannot directly address the
5501                  memory location, since this will make it harder to
5502                  reuse address reloads, and increases register pressure.
5503                  Also don't do this if we can probably update x directly.  */
5504               rtx equiv = (GET_CODE (XEXP (x, 0)) == MEM
5505                            ? XEXP (x, 0)
5506                            : reg_equiv_mem[regno]);
5507               int icode = (int) add_optab->handlers[(int) Pmode].insn_code;
5508               if (insn && GET_CODE (insn) == INSN && equiv
5509                   && memory_operand (equiv, GET_MODE (equiv))
5510 #ifdef HAVE_cc0
5511                   && ! sets_cc0_p (PATTERN (insn))
5512 #endif
5513                   && ! (icode != CODE_FOR_nothing
5514                         && ((*insn_data[icode].operand[0].predicate)
5515                             (equiv, Pmode))
5516                         && ((*insn_data[icode].operand[1].predicate)
5517                             (equiv, Pmode))))
5518                 {
5519                   /* We use the original pseudo for loc, so that
5520                      emit_reload_insns() knows which pseudo this
5521                      reload refers to and updates the pseudo rtx, not
5522                      its equivalent memory location, as well as the
5523                      corresponding entry in reg_last_reload_reg.  */
5524                   loc = &XEXP (x_orig, 0);
5525                   x = XEXP (x, 0);
5526                   reloadnum
5527                     = push_reload (x, x, loc, loc,
5528                                    (context ? INDEX_REG_CLASS :
5529                                     MODE_BASE_REG_CLASS (mode)),
5530                                    GET_MODE (x), GET_MODE (x), 0, 0,
5531                                    opnum, RELOAD_OTHER);
5532                 }
5533               else
5534                 {
5535                   reloadnum
5536                     = push_reload (x, NULL_RTX, loc, (rtx*) 0,
5537                                    (context ? INDEX_REG_CLASS :
5538                                     MODE_BASE_REG_CLASS (mode)),
5539                                    GET_MODE (x), GET_MODE (x), 0, 0,
5540                                    opnum, type);
5541                   rld[reloadnum].inc
5542                     = find_inc_amount (PATTERN (this_insn), XEXP (x_orig, 0));
5543
5544                   value = 1;
5545                 }
5546
5547               update_auto_inc_notes (this_insn, REGNO (XEXP (x_orig, 0)),
5548                                      reloadnum);
5549             }
5550           return value;
5551         }
5552
5553       else if (GET_CODE (XEXP (x, 0)) == MEM)
5554         {
5555           /* This is probably the result of a substitution, by eliminate_regs,
5556              of an equivalent address for a pseudo that was not allocated to a
5557              hard register.  Verify that the specified address is valid and
5558              reload it into a register.  */
5559           /* Variable `tem' might or might not be used in FIND_REG_INC_NOTE.  */
5560           rtx tem ATTRIBUTE_UNUSED = XEXP (x, 0);
5561           rtx link;
5562           int reloadnum;
5563
5564           /* Since we know we are going to reload this item, don't decrement
5565              for the indirection level.
5566
5567              Note that this is actually conservative:  it would be slightly
5568              more efficient to use the value of SPILL_INDIRECT_LEVELS from
5569              reload1.c here.  */
5570           /* We can't use ADDR_TYPE (type) here, because we need to
5571              write back the value after reading it, hence we actually
5572              need two registers.  */
5573           find_reloads_address (GET_MODE (x), &XEXP (x, 0),
5574                                 XEXP (XEXP (x, 0), 0), &XEXP (XEXP (x, 0), 0),
5575                                 opnum, type, ind_levels, insn);
5576
5577           reloadnum = push_reload (x, NULL_RTX, loc, (rtx*) 0,
5578                                    (context ? INDEX_REG_CLASS :
5579                                     MODE_BASE_REG_CLASS (mode)),
5580                                    GET_MODE (x), VOIDmode, 0, 0, opnum, type);
5581           rld[reloadnum].inc
5582             = find_inc_amount (PATTERN (this_insn), XEXP (x, 0));
5583
5584           link = FIND_REG_INC_NOTE (this_insn, tem);
5585           if (link != 0)
5586             push_replacement (&XEXP (link, 0), reloadnum, VOIDmode);
5587
5588           return 1;
5589         }
5590       return 0;
5591
5592     case MEM:
5593       /* This is probably the result of a substitution, by eliminate_regs, of
5594          an equivalent address for a pseudo that was not allocated to a hard
5595          register.  Verify that the specified address is valid and reload it
5596          into a register.
5597
5598          Since we know we are going to reload this item, don't decrement for
5599          the indirection level.
5600
5601          Note that this is actually conservative:  it would be slightly more
5602          efficient to use the value of SPILL_INDIRECT_LEVELS from
5603          reload1.c here.  */
5604
5605       find_reloads_address (GET_MODE (x), loc, XEXP (x, 0), &XEXP (x, 0),
5606                             opnum, ADDR_TYPE (type), ind_levels, insn);
5607       push_reload (*loc, NULL_RTX, loc, (rtx*) 0,
5608                    (context ? INDEX_REG_CLASS : MODE_BASE_REG_CLASS (mode)),
5609                    GET_MODE (x), VOIDmode, 0, 0, opnum, type);
5610       return 1;
5611
5612     case REG:
5613       {
5614         int regno = REGNO (x);
5615
5616         if (reg_equiv_constant[regno] != 0)
5617           {
5618             find_reloads_address_part (reg_equiv_constant[regno], loc,
5619                                        (context ? INDEX_REG_CLASS :
5620                                         MODE_BASE_REG_CLASS (mode)),
5621                                        GET_MODE (x), opnum, type, ind_levels);
5622             return 1;
5623           }
5624
5625 #if 0 /* This might screw code in reload1.c to delete prior output-reload
5626          that feeds this insn.  */
5627         if (reg_equiv_mem[regno] != 0)
5628           {
5629             push_reload (reg_equiv_mem[regno], NULL_RTX, loc, (rtx*) 0,
5630                          (context ? INDEX_REG_CLASS :
5631                           MODE_BASE_REG_CLASS (mode)),
5632                          GET_MODE (x), VOIDmode, 0, 0, opnum, type);
5633             return 1;
5634           }
5635 #endif
5636
5637         if (reg_equiv_memory_loc[regno]
5638             && (reg_equiv_address[regno] != 0 || num_not_at_initial_offset))
5639           {
5640             rtx tem = make_memloc (x, regno);
5641             if (reg_equiv_address[regno] != 0
5642                 || ! rtx_equal_p (tem, reg_equiv_mem[regno]))
5643               {
5644                 x = tem;
5645                 find_reloads_address (GET_MODE (x), &x, XEXP (x, 0),
5646                                       &XEXP (x, 0), opnum, ADDR_TYPE (type),
5647                                       ind_levels, insn);
5648               }
5649           }
5650
5651         if (reg_renumber[regno] >= 0)
5652           regno = reg_renumber[regno];
5653
5654         if ((regno >= FIRST_PSEUDO_REGISTER
5655              || !(context ? REGNO_OK_FOR_INDEX_P (regno)
5656                   : REGNO_MODE_OK_FOR_BASE_P (regno, mode))))
5657           {
5658             push_reload (x, NULL_RTX, loc, (rtx*) 0,
5659                          (context ? INDEX_REG_CLASS : MODE_BASE_REG_CLASS (mode)),
5660                          GET_MODE (x), VOIDmode, 0, 0, opnum, type);
5661             return 1;
5662           }
5663
5664         /* If a register appearing in an address is the subject of a CLOBBER
5665            in this insn, reload it into some other register to be safe.
5666            The CLOBBER is supposed to make the register unavailable
5667            from before this insn to after it.  */
5668         if (regno_clobbered_p (regno, this_insn, GET_MODE (x), 0))
5669           {
5670             push_reload (x, NULL_RTX, loc, (rtx*) 0,
5671                          (context ? INDEX_REG_CLASS : MODE_BASE_REG_CLASS (mode)),
5672                          GET_MODE (x), VOIDmode, 0, 0, opnum, type);
5673             return 1;
5674           }
5675       }
5676       return 0;
5677
5678     case SUBREG:
5679       if (GET_CODE (SUBREG_REG (x)) == REG)
5680         {
5681           /* If this is a SUBREG of a hard register and the resulting register
5682              is of the wrong class, reload the whole SUBREG.  This avoids
5683              needless copies if SUBREG_REG is multi-word.  */
5684           if (REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
5685             {
5686               int regno ATTRIBUTE_UNUSED = subreg_regno (x);
5687
5688               if (! (context ? REGNO_OK_FOR_INDEX_P (regno)
5689                      : REGNO_MODE_OK_FOR_BASE_P (regno, mode)))
5690                 {
5691                   push_reload (x, NULL_RTX, loc, (rtx*) 0,
5692                                (context ? INDEX_REG_CLASS :
5693                                 MODE_BASE_REG_CLASS (mode)),
5694                                GET_MODE (x), VOIDmode, 0, 0, opnum, type);
5695                   return 1;
5696                 }
5697             }
5698           /* If this is a SUBREG of a pseudo-register, and the pseudo-register
5699              is larger than the class size, then reload the whole SUBREG.  */
5700           else
5701             {
5702               enum reg_class class = (context ? INDEX_REG_CLASS
5703                                       : MODE_BASE_REG_CLASS (mode));
5704               if ((unsigned) CLASS_MAX_NREGS (class, GET_MODE (SUBREG_REG (x)))
5705                   > reg_class_size[class])
5706                 {
5707                   x = find_reloads_subreg_address (x, 0, opnum, type,
5708                                                    ind_levels, insn);
5709                   push_reload (x, NULL_RTX, loc, (rtx*) 0, class,
5710                                GET_MODE (x), VOIDmode, 0, 0, opnum, type);
5711                   return 1;
5712                 }
5713             }
5714         }
5715       break;
5716
5717     default:
5718       break;
5719     }
5720
5721   {
5722     const char *fmt = GET_RTX_FORMAT (code);
5723     int i;
5724
5725     for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
5726       {
5727         if (fmt[i] == 'e')
5728           find_reloads_address_1 (mode, XEXP (x, i), context, &XEXP (x, i),
5729                                   opnum, type, ind_levels, insn);
5730       }
5731   }
5732
5733   return 0;
5734 }
5735 \f
5736 /* X, which is found at *LOC, is a part of an address that needs to be
5737    reloaded into a register of class CLASS.  If X is a constant, or if
5738    X is a PLUS that contains a constant, check that the constant is a
5739    legitimate operand and that we are supposed to be able to load
5740    it into the register.
5741
5742    If not, force the constant into memory and reload the MEM instead.
5743
5744    MODE is the mode to use, in case X is an integer constant.
5745
5746    OPNUM and TYPE describe the purpose of any reloads made.
5747
5748    IND_LEVELS says how many levels of indirect addressing this machine
5749    supports.  */
5750
5751 static void
5752 find_reloads_address_part (x, loc, class, mode, opnum, type, ind_levels)
5753      rtx x;
5754      rtx *loc;
5755      enum reg_class class;
5756      enum machine_mode mode;
5757      int opnum;
5758      enum reload_type type;
5759      int ind_levels;
5760 {
5761   if (CONSTANT_P (x)
5762       && (! LEGITIMATE_CONSTANT_P (x)
5763           || PREFERRED_RELOAD_CLASS (x, class) == NO_REGS))
5764     {
5765       rtx tem;
5766
5767       tem = x = force_const_mem (mode, x);
5768       find_reloads_address (mode, &tem, XEXP (tem, 0), &XEXP (tem, 0),
5769                             opnum, type, ind_levels, 0);
5770     }
5771
5772   else if (GET_CODE (x) == PLUS
5773            && CONSTANT_P (XEXP (x, 1))
5774            && (! LEGITIMATE_CONSTANT_P (XEXP (x, 1))
5775                || PREFERRED_RELOAD_CLASS (XEXP (x, 1), class) == NO_REGS))
5776     {
5777       rtx tem;
5778
5779       tem = force_const_mem (GET_MODE (x), XEXP (x, 1));
5780       x = gen_rtx_PLUS (GET_MODE (x), XEXP (x, 0), tem);
5781       find_reloads_address (mode, &tem, XEXP (tem, 0), &XEXP (tem, 0),
5782                             opnum, type, ind_levels, 0);
5783     }
5784
5785   push_reload (x, NULL_RTX, loc, (rtx*) 0, class,
5786                mode, VOIDmode, 0, 0, opnum, type);
5787 }
5788 \f
5789 /* X, a subreg of a pseudo, is a part of an address that needs to be
5790    reloaded.
5791
5792    If the pseudo is equivalent to a memory location that cannot be directly
5793    addressed, make the necessary address reloads.
5794
5795    If address reloads have been necessary, or if the address is changed
5796    by register elimination, return the rtx of the memory location;
5797    otherwise, return X.
5798
5799    If FORCE_REPLACE is nonzero, unconditionally replace the subreg with the
5800    memory location.
5801
5802    OPNUM and TYPE identify the purpose of the reload.
5803
5804    IND_LEVELS says how many levels of indirect addressing are
5805    supported at this point in the address.
5806
5807    INSN, if nonzero, is the insn in which we do the reload.  It is used
5808    to determine where to put USEs for pseudos that we have to replace with
5809    stack slots.  */
5810
5811 static rtx
5812 find_reloads_subreg_address (x, force_replace, opnum, type,
5813                              ind_levels, insn)
5814      rtx x;
5815      int force_replace;
5816      int opnum;
5817      enum reload_type type;
5818      int ind_levels;
5819      rtx insn;
5820 {
5821   int regno = REGNO (SUBREG_REG (x));
5822
5823   if (reg_equiv_memory_loc[regno])
5824     {
5825       /* If the address is not directly addressable, or if the address is not
5826          offsettable, then it must be replaced.  */
5827       if (! force_replace
5828           && (reg_equiv_address[regno]
5829               || ! offsettable_memref_p (reg_equiv_mem[regno])))
5830         force_replace = 1;
5831
5832       if (force_replace || num_not_at_initial_offset)
5833         {
5834           rtx tem = make_memloc (SUBREG_REG (x), regno);
5835
5836           /* If the address changes because of register elimination, then
5837              it must be replaced.  */
5838           if (force_replace
5839               || ! rtx_equal_p (tem, reg_equiv_mem[regno]))
5840             {
5841               int offset = SUBREG_BYTE (x);
5842               unsigned outer_size = GET_MODE_SIZE (GET_MODE (x));
5843               unsigned inner_size = GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)));
5844
5845               XEXP (tem, 0) = plus_constant (XEXP (tem, 0), offset);
5846               PUT_MODE (tem, GET_MODE (x));
5847
5848               /* If this was a paradoxical subreg that we replaced, the
5849                  resulting memory must be sufficiently aligned to allow
5850                  us to widen the mode of the memory.  */
5851               if (outer_size > inner_size && STRICT_ALIGNMENT)
5852                 {
5853                   rtx base;
5854
5855                   base = XEXP (tem, 0);
5856                   if (GET_CODE (base) == PLUS)
5857                     {
5858                       if (GET_CODE (XEXP (base, 1)) == CONST_INT
5859                           && INTVAL (XEXP (base, 1)) % outer_size != 0)
5860                         return x;
5861                       base = XEXP (base, 0);
5862                     }
5863                   if (GET_CODE (base) != REG
5864                       || (REGNO_POINTER_ALIGN (REGNO (base))
5865                           < outer_size * BITS_PER_UNIT))
5866                     return x;
5867                 }
5868
5869               find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
5870                                     &XEXP (tem, 0), opnum, ADDR_TYPE (type),
5871                                     ind_levels, insn);
5872
5873               /* If this is not a toplevel operand, find_reloads doesn't see
5874                  this substitution.  We have to emit a USE of the pseudo so
5875                  that delete_output_reload can see it.  */
5876               if (replace_reloads && recog_data.operand[opnum] != x)
5877                 /* We mark the USE with QImode so that we recognize it
5878                    as one that can be safely deleted at the end of
5879                    reload.  */
5880                 PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode,
5881                                                          SUBREG_REG (x)),
5882                                             insn), QImode);
5883               x = tem;
5884             }
5885         }
5886     }
5887   return x;
5888 }
5889 \f
5890 /* Substitute into the current INSN the registers into which we have reloaded
5891    the things that need reloading.  The array `replacements'
5892    contains the locations of all pointers that must be changed
5893    and says what to replace them with.
5894
5895    Return the rtx that X translates into; usually X, but modified.  */
5896
5897 void
5898 subst_reloads (insn)
5899      rtx insn;
5900 {
5901   int i;
5902
5903   for (i = 0; i < n_replacements; i++)
5904     {
5905       struct replacement *r = &replacements[i];
5906       rtx reloadreg = rld[r->what].reg_rtx;
5907       if (reloadreg)
5908         {
5909 #ifdef ENABLE_CHECKING
5910           /* Internal consistency test.  Check that we don't modify
5911              anything in the equivalence arrays.  Whenever something from
5912              those arrays needs to be reloaded, it must be unshared before
5913              being substituted into; the equivalence must not be modified.
5914              Otherwise, if the equivalence is used after that, it will
5915              have been modified, and the thing substituted (probably a
5916              register) is likely overwritten and not a usable equivalence.  */
5917           int check_regno;
5918
5919           for (check_regno = 0; check_regno < max_regno; check_regno++)
5920             {
5921 #define CHECK_MODF(ARRAY)                                               \
5922               if (ARRAY[check_regno]                                    \
5923                   && loc_mentioned_in_p (r->where,                      \
5924                                          ARRAY[check_regno]))           \
5925                 abort ()
5926
5927               CHECK_MODF (reg_equiv_constant);
5928               CHECK_MODF (reg_equiv_memory_loc);
5929               CHECK_MODF (reg_equiv_address);
5930               CHECK_MODF (reg_equiv_mem);
5931 #undef CHECK_MODF
5932             }
5933 #endif /* ENABLE_CHECKING */
5934
5935           /* If we're replacing a LABEL_REF with a register, add a
5936              REG_LABEL note to indicate to flow which label this
5937              register refers to.  */
5938           if (GET_CODE (*r->where) == LABEL_REF
5939               && GET_CODE (insn) == JUMP_INSN)
5940             REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_LABEL,
5941                                                   XEXP (*r->where, 0),
5942                                                   REG_NOTES (insn));
5943
5944           /* Encapsulate RELOADREG so its machine mode matches what
5945              used to be there.  Note that gen_lowpart_common will
5946              do the wrong thing if RELOADREG is multi-word.  RELOADREG
5947              will always be a REG here.  */
5948           if (GET_MODE (reloadreg) != r->mode && r->mode != VOIDmode)
5949             reloadreg = reload_adjust_reg_for_mode (reloadreg, r->mode);
5950
5951           /* If we are putting this into a SUBREG and RELOADREG is a
5952              SUBREG, we would be making nested SUBREGs, so we have to fix
5953              this up.  Note that r->where == &SUBREG_REG (*r->subreg_loc).  */
5954
5955           if (r->subreg_loc != 0 && GET_CODE (reloadreg) == SUBREG)
5956             {
5957               if (GET_MODE (*r->subreg_loc)
5958                   == GET_MODE (SUBREG_REG (reloadreg)))
5959                 *r->subreg_loc = SUBREG_REG (reloadreg);
5960               else
5961                 {
5962                   int final_offset =
5963                     SUBREG_BYTE (*r->subreg_loc) + SUBREG_BYTE (reloadreg);
5964
5965                   /* When working with SUBREGs the rule is that the byte
5966                      offset must be a multiple of the SUBREG's mode.  */
5967                   final_offset = (final_offset /
5968                                   GET_MODE_SIZE (GET_MODE (*r->subreg_loc)));
5969                   final_offset = (final_offset *
5970                                   GET_MODE_SIZE (GET_MODE (*r->subreg_loc)));
5971
5972                   *r->where = SUBREG_REG (reloadreg);
5973                   SUBREG_BYTE (*r->subreg_loc) = final_offset;
5974                 }
5975             }
5976           else
5977             *r->where = reloadreg;
5978         }
5979       /* If reload got no reg and isn't optional, something's wrong.  */
5980       else if (! rld[r->what].optional)
5981         abort ();
5982     }
5983 }
5984 \f
5985 /* Make a copy of any replacements being done into X and move those
5986    copies to locations in Y, a copy of X.  */
5987
5988 void
5989 copy_replacements (x, y)
5990      rtx x, y;
5991 {
5992   /* We can't support X being a SUBREG because we might then need to know its
5993      location if something inside it was replaced.  */
5994   if (GET_CODE (x) == SUBREG)
5995     abort ();
5996
5997   copy_replacements_1 (&x, &y, n_replacements);
5998 }
5999
6000 static void
6001 copy_replacements_1 (px, py, orig_replacements)
6002      rtx *px;
6003      rtx *py;
6004      int orig_replacements;
6005 {
6006   int i, j;
6007   rtx x, y;
6008   struct replacement *r;
6009   enum rtx_code code;
6010   const char *fmt;
6011
6012   for (j = 0; j < orig_replacements; j++)
6013     {
6014       if (replacements[j].subreg_loc == px)
6015         {
6016           r = &replacements[n_replacements++];
6017           r->where = replacements[j].where;
6018           r->subreg_loc = py;
6019           r->what = replacements[j].what;
6020           r->mode = replacements[j].mode;
6021         }
6022       else if (replacements[j].where == px)
6023         {
6024           r = &replacements[n_replacements++];
6025           r->where = py;
6026           r->subreg_loc = 0;
6027           r->what = replacements[j].what;
6028           r->mode = replacements[j].mode;
6029         }
6030     }
6031
6032   x = *px;
6033   y = *py;
6034   code = GET_CODE (x);
6035   fmt = GET_RTX_FORMAT (code);
6036
6037   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
6038     {
6039       if (fmt[i] == 'e')
6040         copy_replacements_1 (&XEXP (x, i), &XEXP (y, i), orig_replacements);
6041       else if (fmt[i] == 'E')
6042         for (j = XVECLEN (x, i); --j >= 0; )
6043           copy_replacements_1 (&XVECEXP (x, i, j), &XVECEXP (y, i, j),
6044                                orig_replacements);
6045     }
6046 }
6047
6048 /* Change any replacements being done to *X to be done to *Y.  */
6049
6050 void
6051 move_replacements (x, y)
6052      rtx *x;
6053      rtx *y;
6054 {
6055   int i;
6056
6057   for (i = 0; i < n_replacements; i++)
6058     if (replacements[i].subreg_loc == x)
6059       replacements[i].subreg_loc = y;
6060     else if (replacements[i].where == x)
6061       {
6062         replacements[i].where = y;
6063         replacements[i].subreg_loc = 0;
6064       }
6065 }
6066 \f
6067 /* If LOC was scheduled to be replaced by something, return the replacement.
6068    Otherwise, return *LOC.  */
6069
6070 rtx
6071 find_replacement (loc)
6072      rtx *loc;
6073 {
6074   struct replacement *r;
6075
6076   for (r = &replacements[0]; r < &replacements[n_replacements]; r++)
6077     {
6078       rtx reloadreg = rld[r->what].reg_rtx;
6079
6080       if (reloadreg && r->where == loc)
6081         {
6082           if (r->mode != VOIDmode && GET_MODE (reloadreg) != r->mode)
6083             reloadreg = gen_rtx_REG (r->mode, REGNO (reloadreg));
6084
6085           return reloadreg;
6086         }
6087       else if (reloadreg && r->subreg_loc == loc)
6088         {
6089           /* RELOADREG must be either a REG or a SUBREG.
6090
6091              ??? Is it actually still ever a SUBREG?  If so, why?  */
6092
6093           if (GET_CODE (reloadreg) == REG)
6094             return gen_rtx_REG (GET_MODE (*loc),
6095                                 (REGNO (reloadreg) +
6096                                  subreg_regno_offset (REGNO (SUBREG_REG (*loc)),
6097                                                       GET_MODE (SUBREG_REG (*loc)),
6098                                                       SUBREG_BYTE (*loc),
6099                                                       GET_MODE (*loc))));
6100           else if (GET_MODE (reloadreg) == GET_MODE (*loc))
6101             return reloadreg;
6102           else
6103             {
6104               int final_offset = SUBREG_BYTE (reloadreg) + SUBREG_BYTE (*loc);
6105
6106               /* When working with SUBREGs the rule is that the byte
6107                  offset must be a multiple of the SUBREG's mode.  */
6108               final_offset = (final_offset / GET_MODE_SIZE (GET_MODE (*loc)));
6109               final_offset = (final_offset * GET_MODE_SIZE (GET_MODE (*loc)));
6110               return gen_rtx_SUBREG (GET_MODE (*loc), SUBREG_REG (reloadreg),
6111                                      final_offset);
6112             }
6113         }
6114     }
6115
6116   /* If *LOC is a PLUS, MINUS, or MULT, see if a replacement is scheduled for
6117      what's inside and make a new rtl if so.  */
6118   if (GET_CODE (*loc) == PLUS || GET_CODE (*loc) == MINUS
6119       || GET_CODE (*loc) == MULT)
6120     {
6121       rtx x = find_replacement (&XEXP (*loc, 0));
6122       rtx y = find_replacement (&XEXP (*loc, 1));
6123
6124       if (x != XEXP (*loc, 0) || y != XEXP (*loc, 1))
6125         return gen_rtx_fmt_ee (GET_CODE (*loc), GET_MODE (*loc), x, y);
6126     }
6127
6128   return *loc;
6129 }
6130 \f
6131 /* Return nonzero if register in range [REGNO, ENDREGNO)
6132    appears either explicitly or implicitly in X
6133    other than being stored into (except for earlyclobber operands).
6134
6135    References contained within the substructure at LOC do not count.
6136    LOC may be zero, meaning don't ignore anything.
6137
6138    This is similar to refers_to_regno_p in rtlanal.c except that we
6139    look at equivalences for pseudos that didn't get hard registers.  */
6140
6141 int
6142 refers_to_regno_for_reload_p (regno, endregno, x, loc)
6143      unsigned int regno, endregno;
6144      rtx x;
6145      rtx *loc;
6146 {
6147   int i;
6148   unsigned int r;
6149   RTX_CODE code;
6150   const char *fmt;
6151
6152   if (x == 0)
6153     return 0;
6154
6155  repeat:
6156   code = GET_CODE (x);
6157
6158   switch (code)
6159     {
6160     case REG:
6161       r = REGNO (x);
6162
6163       /* If this is a pseudo, a hard register must not have been allocated.
6164          X must therefore either be a constant or be in memory.  */
6165       if (r >= FIRST_PSEUDO_REGISTER)
6166         {
6167           if (reg_equiv_memory_loc[r])
6168             return refers_to_regno_for_reload_p (regno, endregno,
6169                                                  reg_equiv_memory_loc[r],
6170                                                  (rtx*) 0);
6171
6172           if (reg_equiv_constant[r])
6173             return 0;
6174
6175           abort ();
6176         }
6177
6178       return (endregno > r
6179               && regno < r + (r < FIRST_PSEUDO_REGISTER
6180                               ? HARD_REGNO_NREGS (r, GET_MODE (x))
6181                               : 1));
6182
6183     case SUBREG:
6184       /* If this is a SUBREG of a hard reg, we can see exactly which
6185          registers are being modified.  Otherwise, handle normally.  */
6186       if (GET_CODE (SUBREG_REG (x)) == REG
6187           && REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
6188         {
6189           unsigned int inner_regno = subreg_regno (x);
6190           unsigned int inner_endregno
6191             = inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
6192                              ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
6193
6194           return endregno > inner_regno && regno < inner_endregno;
6195         }
6196       break;
6197
6198     case CLOBBER:
6199     case SET:
6200       if (&SET_DEST (x) != loc
6201           /* Note setting a SUBREG counts as referring to the REG it is in for
6202              a pseudo but not for hard registers since we can
6203              treat each word individually.  */
6204           && ((GET_CODE (SET_DEST (x)) == SUBREG
6205                && loc != &SUBREG_REG (SET_DEST (x))
6206                && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG
6207                && REGNO (SUBREG_REG (SET_DEST (x))) >= FIRST_PSEUDO_REGISTER
6208                && refers_to_regno_for_reload_p (regno, endregno,
6209                                                 SUBREG_REG (SET_DEST (x)),
6210                                                 loc))
6211               /* If the output is an earlyclobber operand, this is
6212                  a conflict.  */
6213               || ((GET_CODE (SET_DEST (x)) != REG
6214                    || earlyclobber_operand_p (SET_DEST (x)))
6215                   && refers_to_regno_for_reload_p (regno, endregno,
6216                                                    SET_DEST (x), loc))))
6217         return 1;
6218
6219       if (code == CLOBBER || loc == &SET_SRC (x))
6220         return 0;
6221       x = SET_SRC (x);
6222       goto repeat;
6223
6224     default:
6225       break;
6226     }
6227
6228   /* X does not match, so try its subexpressions.  */
6229
6230   fmt = GET_RTX_FORMAT (code);
6231   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
6232     {
6233       if (fmt[i] == 'e' && loc != &XEXP (x, i))
6234         {
6235           if (i == 0)
6236             {
6237               x = XEXP (x, 0);
6238               goto repeat;
6239             }
6240           else
6241             if (refers_to_regno_for_reload_p (regno, endregno,
6242                                               XEXP (x, i), loc))
6243               return 1;
6244         }
6245       else if (fmt[i] == 'E')
6246         {
6247           int j;
6248           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
6249             if (loc != &XVECEXP (x, i, j)
6250                 && refers_to_regno_for_reload_p (regno, endregno,
6251                                                  XVECEXP (x, i, j), loc))
6252               return 1;
6253         }
6254     }
6255   return 0;
6256 }
6257
6258 /* Nonzero if modifying X will affect IN.  If X is a register or a SUBREG,
6259    we check if any register number in X conflicts with the relevant register
6260    numbers.  If X is a constant, return 0.  If X is a MEM, return 1 iff IN
6261    contains a MEM (we don't bother checking for memory addresses that can't
6262    conflict because we expect this to be a rare case.
6263
6264    This function is similar to reg_overlap_mentioned_p in rtlanal.c except
6265    that we look at equivalences for pseudos that didn't get hard registers.  */
6266
6267 int
6268 reg_overlap_mentioned_for_reload_p (x, in)
6269      rtx x, in;
6270 {
6271   int regno, endregno;
6272
6273   /* Overly conservative.  */
6274   if (GET_CODE (x) == STRICT_LOW_PART
6275       || GET_RTX_CLASS (GET_CODE (x)) == 'a')
6276     x = XEXP (x, 0);
6277
6278   /* If either argument is a constant, then modifying X can not affect IN.  */
6279   if (CONSTANT_P (x) || CONSTANT_P (in))
6280     return 0;
6281   else if (GET_CODE (x) == SUBREG)
6282     {
6283       regno = REGNO (SUBREG_REG (x));
6284       if (regno < FIRST_PSEUDO_REGISTER)
6285         regno += subreg_regno_offset (REGNO (SUBREG_REG (x)),
6286                                       GET_MODE (SUBREG_REG (x)),
6287                                       SUBREG_BYTE (x),
6288                                       GET_MODE (x));
6289     }
6290   else if (GET_CODE (x) == REG)
6291     {
6292       regno = REGNO (x);
6293
6294       /* If this is a pseudo, it must not have been assigned a hard register.
6295          Therefore, it must either be in memory or be a constant.  */
6296
6297       if (regno >= FIRST_PSEUDO_REGISTER)
6298         {
6299           if (reg_equiv_memory_loc[regno])
6300             return refers_to_mem_for_reload_p (in);
6301           else if (reg_equiv_constant[regno])
6302             return 0;
6303           abort ();
6304         }
6305     }
6306   else if (GET_CODE (x) == MEM)
6307     return refers_to_mem_for_reload_p (in);
6308   else if (GET_CODE (x) == SCRATCH || GET_CODE (x) == PC
6309            || GET_CODE (x) == CC0)
6310     return reg_mentioned_p (x, in);
6311   else if (GET_CODE (x) == PLUS)
6312     return (reg_overlap_mentioned_for_reload_p (XEXP (x, 0), in)
6313             || reg_overlap_mentioned_for_reload_p (XEXP (x, 1), in));
6314   else
6315     abort ();
6316
6317   endregno = regno + (regno < FIRST_PSEUDO_REGISTER
6318                       ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
6319
6320   return refers_to_regno_for_reload_p (regno, endregno, in, (rtx*) 0);
6321 }
6322
6323 /* Return nonzero if anything in X contains a MEM.  Look also for pseudo
6324    registers.  */
6325
6326 int
6327 refers_to_mem_for_reload_p (x)
6328      rtx x;
6329 {
6330   const char *fmt;
6331   int i;
6332
6333   if (GET_CODE (x) == MEM)
6334     return 1;
6335
6336   if (GET_CODE (x) == REG)
6337     return (REGNO (x) >= FIRST_PSEUDO_REGISTER
6338             && reg_equiv_memory_loc[REGNO (x)]);
6339
6340   fmt = GET_RTX_FORMAT (GET_CODE (x));
6341   for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
6342     if (fmt[i] == 'e'
6343         && (GET_CODE (XEXP (x, i)) == MEM
6344             || refers_to_mem_for_reload_p (XEXP (x, i))))
6345       return 1;
6346
6347   return 0;
6348 }
6349 \f
6350 /* Check the insns before INSN to see if there is a suitable register
6351    containing the same value as GOAL.
6352    If OTHER is -1, look for a register in class CLASS.
6353    Otherwise, just see if register number OTHER shares GOAL's value.
6354
6355    Return an rtx for the register found, or zero if none is found.
6356
6357    If RELOAD_REG_P is (short *)1,
6358    we reject any hard reg that appears in reload_reg_rtx
6359    because such a hard reg is also needed coming into this insn.
6360
6361    If RELOAD_REG_P is any other nonzero value,
6362    it is a vector indexed by hard reg number
6363    and we reject any hard reg whose element in the vector is nonnegative
6364    as well as any that appears in reload_reg_rtx.
6365
6366    If GOAL is zero, then GOALREG is a register number; we look
6367    for an equivalent for that register.
6368
6369    MODE is the machine mode of the value we want an equivalence for.
6370    If GOAL is nonzero and not VOIDmode, then it must have mode MODE.
6371
6372    This function is used by jump.c as well as in the reload pass.
6373
6374    If GOAL is the sum of the stack pointer and a constant, we treat it
6375    as if it were a constant except that sp is required to be unchanging.  */
6376
6377 rtx
6378 find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
6379      rtx goal;
6380      rtx insn;
6381      enum reg_class class;
6382      int other;
6383      short *reload_reg_p;
6384      int goalreg;
6385      enum machine_mode mode;
6386 {
6387   rtx p = insn;
6388   rtx goaltry, valtry, value, where;
6389   rtx pat;
6390   int regno = -1;
6391   int valueno;
6392   int goal_mem = 0;
6393   int goal_const = 0;
6394   int goal_mem_addr_varies = 0;
6395   int need_stable_sp = 0;
6396   int nregs;
6397   int valuenregs;
6398
6399   if (goal == 0)
6400     regno = goalreg;
6401   else if (GET_CODE (goal) == REG)
6402     regno = REGNO (goal);
6403   else if (GET_CODE (goal) == MEM)
6404     {
6405       enum rtx_code code = GET_CODE (XEXP (goal, 0));
6406       if (MEM_VOLATILE_P (goal))
6407         return 0;
6408       if (flag_float_store && GET_MODE_CLASS (GET_MODE (goal)) == MODE_FLOAT)
6409         return 0;
6410       /* An address with side effects must be reexecuted.  */
6411       switch (code)
6412         {
6413         case POST_INC:
6414         case PRE_INC:
6415         case POST_DEC:
6416         case PRE_DEC:
6417         case POST_MODIFY:
6418         case PRE_MODIFY:
6419           return 0;
6420         default:
6421           break;
6422         }
6423       goal_mem = 1;
6424     }
6425   else if (CONSTANT_P (goal))
6426     goal_const = 1;
6427   else if (GET_CODE (goal) == PLUS
6428            && XEXP (goal, 0) == stack_pointer_rtx
6429            && CONSTANT_P (XEXP (goal, 1)))
6430     goal_const = need_stable_sp = 1;
6431   else if (GET_CODE (goal) == PLUS
6432            && XEXP (goal, 0) == frame_pointer_rtx
6433            && CONSTANT_P (XEXP (goal, 1)))
6434     goal_const = 1;
6435   else
6436     return 0;
6437
6438   /* Scan insns back from INSN, looking for one that copies
6439      a value into or out of GOAL.
6440      Stop and give up if we reach a label.  */
6441
6442   while (1)
6443     {
6444       p = PREV_INSN (p);
6445       if (p == 0 || GET_CODE (p) == CODE_LABEL)
6446         return 0;
6447
6448       if (GET_CODE (p) == INSN
6449           /* If we don't want spill regs ...  */
6450           && (! (reload_reg_p != 0
6451                  && reload_reg_p != (short *) (HOST_WIDE_INT) 1)
6452               /* ... then ignore insns introduced by reload; they aren't
6453                  useful and can cause results in reload_as_needed to be
6454                  different from what they were when calculating the need for
6455                  spills.  If we notice an input-reload insn here, we will
6456                  reject it below, but it might hide a usable equivalent.
6457                  That makes bad code.  It may even abort: perhaps no reg was
6458                  spilled for this insn because it was assumed we would find
6459                  that equivalent.  */
6460               || INSN_UID (p) < reload_first_uid))
6461         {
6462           rtx tem;
6463           pat = single_set (p);
6464
6465           /* First check for something that sets some reg equal to GOAL.  */
6466           if (pat != 0
6467               && ((regno >= 0
6468                    && true_regnum (SET_SRC (pat)) == regno
6469                    && (valueno = true_regnum (valtry = SET_DEST (pat))) >= 0)
6470                   ||
6471                   (regno >= 0
6472                    && true_regnum (SET_DEST (pat)) == regno
6473                    && (valueno = true_regnum (valtry = SET_SRC (pat))) >= 0)
6474                   ||
6475                   (goal_const && rtx_equal_p (SET_SRC (pat), goal)
6476                    /* When looking for stack pointer + const,
6477                       make sure we don't use a stack adjust.  */
6478                    && !reg_overlap_mentioned_for_reload_p (SET_DEST (pat), goal)
6479                    && (valueno = true_regnum (valtry = SET_DEST (pat))) >= 0)
6480                   || (goal_mem
6481                       && (valueno = true_regnum (valtry = SET_DEST (pat))) >= 0
6482                       && rtx_renumbered_equal_p (goal, SET_SRC (pat)))
6483                   || (goal_mem
6484                       && (valueno = true_regnum (valtry = SET_SRC (pat))) >= 0
6485                       && rtx_renumbered_equal_p (goal, SET_DEST (pat)))
6486                   /* If we are looking for a constant,
6487                      and something equivalent to that constant was copied
6488                      into a reg, we can use that reg.  */
6489                   || (goal_const && REG_NOTES (p) != 0
6490                       && (tem = find_reg_note (p, REG_EQUIV, NULL_RTX))
6491                       && ((rtx_equal_p (XEXP (tem, 0), goal)
6492                            && (valueno
6493                                = true_regnum (valtry = SET_DEST (pat))) >= 0)
6494                           || (GET_CODE (SET_DEST (pat)) == REG
6495                               && GET_CODE (XEXP (tem, 0)) == CONST_DOUBLE
6496                               && (GET_MODE_CLASS (GET_MODE (XEXP (tem, 0)))
6497                                   == MODE_FLOAT)
6498                               && GET_CODE (goal) == CONST_INT
6499                               && 0 != (goaltry
6500                                        = operand_subword (XEXP (tem, 0), 0, 0,
6501                                                           VOIDmode))
6502                               && rtx_equal_p (goal, goaltry)
6503                               && (valtry
6504                                   = operand_subword (SET_DEST (pat), 0, 0,
6505                                                      VOIDmode))
6506                               && (valueno = true_regnum (valtry)) >= 0)))
6507                   || (goal_const && (tem = find_reg_note (p, REG_EQUIV,
6508                                                           NULL_RTX))
6509                       && GET_CODE (SET_DEST (pat)) == REG
6510                       && GET_CODE (XEXP (tem, 0)) == CONST_DOUBLE
6511                       && (GET_MODE_CLASS (GET_MODE (XEXP (tem, 0)))
6512                           == MODE_FLOAT)
6513                       && GET_CODE (goal) == CONST_INT
6514                       && 0 != (goaltry = operand_subword (XEXP (tem, 0), 1, 0,
6515                                                           VOIDmode))
6516                       && rtx_equal_p (goal, goaltry)
6517                       && (valtry
6518                           = operand_subword (SET_DEST (pat), 1, 0, VOIDmode))
6519                       && (valueno = true_regnum (valtry)) >= 0)))
6520             {
6521               if (other >= 0)
6522                 {
6523                   if (valueno != other)
6524                     continue;
6525                 }
6526               else if ((unsigned) valueno >= FIRST_PSEUDO_REGISTER)
6527                 continue;
6528               else
6529                 {
6530                   int i;
6531
6532                   for (i = HARD_REGNO_NREGS (valueno, mode) - 1; i >= 0; i--)
6533                     if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
6534                                              valueno + i))
6535                       break;
6536                   if (i >= 0)
6537                     continue;
6538                 }
6539               value = valtry;
6540               where = p;
6541               break;
6542             }
6543         }
6544     }
6545
6546   /* We found a previous insn copying GOAL into a suitable other reg VALUE
6547      (or copying VALUE into GOAL, if GOAL is also a register).
6548      Now verify that VALUE is really valid.  */
6549
6550   /* VALUENO is the register number of VALUE; a hard register.  */
6551
6552   /* Don't try to re-use something that is killed in this insn.  We want
6553      to be able to trust REG_UNUSED notes.  */
6554   if (REG_NOTES (where) != 0 && find_reg_note (where, REG_UNUSED, value))
6555     return 0;
6556
6557   /* If we propose to get the value from the stack pointer or if GOAL is
6558      a MEM based on the stack pointer, we need a stable SP.  */
6559   if (valueno == STACK_POINTER_REGNUM || regno == STACK_POINTER_REGNUM
6560       || (goal_mem && reg_overlap_mentioned_for_reload_p (stack_pointer_rtx,
6561                                                           goal)))
6562     need_stable_sp = 1;
6563
6564   /* Reject VALUE if the copy-insn moved the wrong sort of datum.  */
6565   if (GET_MODE (value) != mode)
6566     return 0;
6567
6568   /* Reject VALUE if it was loaded from GOAL
6569      and is also a register that appears in the address of GOAL.  */
6570
6571   if (goal_mem && value == SET_DEST (single_set (where))
6572       && refers_to_regno_for_reload_p (valueno,
6573                                        (valueno
6574                                         + HARD_REGNO_NREGS (valueno, mode)),
6575                                        goal, (rtx*) 0))
6576     return 0;
6577
6578   /* Reject registers that overlap GOAL.  */
6579
6580   if (!goal_mem && !goal_const
6581       && regno + (int) HARD_REGNO_NREGS (regno, mode) > valueno
6582       && regno < valueno + (int) HARD_REGNO_NREGS (valueno, mode))
6583     return 0;
6584
6585   nregs = HARD_REGNO_NREGS (regno, mode);
6586   valuenregs = HARD_REGNO_NREGS (valueno, mode);
6587
6588   /* Reject VALUE if it is one of the regs reserved for reloads.
6589      Reload1 knows how to reuse them anyway, and it would get
6590      confused if we allocated one without its knowledge.
6591      (Now that insns introduced by reload are ignored above,
6592      this case shouldn't happen, but I'm not positive.)  */
6593
6594   if (reload_reg_p != 0 && reload_reg_p != (short *) (HOST_WIDE_INT) 1)
6595     {
6596       int i;
6597       for (i = 0; i < valuenregs; ++i)
6598         if (reload_reg_p[valueno + i] >= 0)
6599           return 0;
6600     }
6601
6602   /* Reject VALUE if it is a register being used for an input reload
6603      even if it is not one of those reserved.  */
6604
6605   if (reload_reg_p != 0)
6606     {
6607       int i;
6608       for (i = 0; i < n_reloads; i++)
6609         if (rld[i].reg_rtx != 0 && rld[i].in)
6610           {
6611             int regno1 = REGNO (rld[i].reg_rtx);
6612             int nregs1 = HARD_REGNO_NREGS (regno1,
6613                                            GET_MODE (rld[i].reg_rtx));
6614             if (regno1 < valueno + valuenregs
6615                 && regno1 + nregs1 > valueno)
6616               return 0;
6617           }
6618     }
6619
6620   if (goal_mem)
6621     /* We must treat frame pointer as varying here,
6622        since it can vary--in a nonlocal goto as generated by expand_goto.  */
6623     goal_mem_addr_varies = !CONSTANT_ADDRESS_P (XEXP (goal, 0));
6624
6625   /* Now verify that the values of GOAL and VALUE remain unaltered
6626      until INSN is reached.  */
6627
6628   p = insn;
6629   while (1)
6630     {
6631       p = PREV_INSN (p);
6632       if (p == where)
6633         return value;
6634
6635       /* Don't trust the conversion past a function call
6636          if either of the two is in a call-clobbered register, or memory.  */
6637       if (GET_CODE (p) == CALL_INSN)
6638         {
6639           int i;
6640
6641           if (goal_mem || need_stable_sp)
6642             return 0;
6643
6644           if (regno >= 0 && regno < FIRST_PSEUDO_REGISTER)
6645             for (i = 0; i < nregs; ++i)
6646               if (call_used_regs[regno + i])
6647                 return 0;
6648
6649           if (valueno >= 0 && valueno < FIRST_PSEUDO_REGISTER)
6650             for (i = 0; i < valuenregs; ++i)
6651               if (call_used_regs[valueno + i])
6652                 return 0;
6653 #ifdef NON_SAVING_SETJMP
6654           if (NON_SAVING_SETJMP && find_reg_note (p, REG_SETJMP, NULL))
6655             return 0;
6656 #endif
6657         }
6658
6659       if (INSN_P (p))
6660         {
6661           pat = PATTERN (p);
6662
6663           /* Watch out for unspec_volatile, and volatile asms.  */
6664           if (volatile_insn_p (pat))
6665             return 0;
6666
6667           /* If this insn P stores in either GOAL or VALUE, return 0.
6668              If GOAL is a memory ref and this insn writes memory, return 0.
6669              If GOAL is a memory ref and its address is not constant,
6670              and this insn P changes a register used in GOAL, return 0.  */
6671
6672           if (GET_CODE (pat) == COND_EXEC)
6673             pat = COND_EXEC_CODE (pat);
6674           if (GET_CODE (pat) == SET || GET_CODE (pat) == CLOBBER)
6675             {
6676               rtx dest = SET_DEST (pat);
6677               while (GET_CODE (dest) == SUBREG
6678                      || GET_CODE (dest) == ZERO_EXTRACT
6679                      || GET_CODE (dest) == SIGN_EXTRACT
6680                      || GET_CODE (dest) == STRICT_LOW_PART)
6681                 dest = XEXP (dest, 0);
6682               if (GET_CODE (dest) == REG)
6683                 {
6684                   int xregno = REGNO (dest);
6685                   int xnregs;
6686                   if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
6687                     xnregs = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
6688                   else
6689                     xnregs = 1;
6690                   if (xregno < regno + nregs && xregno + xnregs > regno)
6691                     return 0;
6692                   if (xregno < valueno + valuenregs
6693                       && xregno + xnregs > valueno)
6694                     return 0;
6695                   if (goal_mem_addr_varies
6696                       && reg_overlap_mentioned_for_reload_p (dest, goal))
6697                     return 0;
6698                   if (xregno == STACK_POINTER_REGNUM && need_stable_sp)
6699                     return 0;
6700                 }
6701               else if (goal_mem && GET_CODE (dest) == MEM
6702                        && ! push_operand (dest, GET_MODE (dest)))
6703                 return 0;
6704               else if (GET_CODE (dest) == MEM && regno >= FIRST_PSEUDO_REGISTER
6705                        && reg_equiv_memory_loc[regno] != 0)
6706                 return 0;
6707               else if (need_stable_sp && push_operand (dest, GET_MODE (dest)))
6708                 return 0;
6709             }
6710           else if (GET_CODE (pat) == PARALLEL)
6711             {
6712               int i;
6713               for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)
6714                 {
6715                   rtx v1 = XVECEXP (pat, 0, i);
6716                   if (GET_CODE (v1) == COND_EXEC)
6717                     v1 = COND_EXEC_CODE (v1);
6718                   if (GET_CODE (v1) == SET || GET_CODE (v1) == CLOBBER)
6719                     {
6720                       rtx dest = SET_DEST (v1);
6721                       while (GET_CODE (dest) == SUBREG
6722                              || GET_CODE (dest) == ZERO_EXTRACT
6723                              || GET_CODE (dest) == SIGN_EXTRACT
6724                              || GET_CODE (dest) == STRICT_LOW_PART)
6725                         dest = XEXP (dest, 0);
6726                       if (GET_CODE (dest) == REG)
6727                         {
6728                           int xregno = REGNO (dest);
6729                           int xnregs;
6730                           if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
6731                             xnregs = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
6732                           else
6733                             xnregs = 1;
6734                           if (xregno < regno + nregs
6735                               && xregno + xnregs > regno)
6736                             return 0;
6737                           if (xregno < valueno + valuenregs
6738                               && xregno + xnregs > valueno)
6739                             return 0;
6740                           if (goal_mem_addr_varies
6741                               && reg_overlap_mentioned_for_reload_p (dest,
6742                                                                      goal))
6743                             return 0;
6744                           if (xregno == STACK_POINTER_REGNUM && need_stable_sp)
6745                             return 0;
6746                         }
6747                       else if (goal_mem && GET_CODE (dest) == MEM
6748                                && ! push_operand (dest, GET_MODE (dest)))
6749                         return 0;
6750                       else if (GET_CODE (dest) == MEM && regno >= FIRST_PSEUDO_REGISTER
6751                                && reg_equiv_memory_loc[regno] != 0)
6752                         return 0;
6753                       else if (need_stable_sp
6754                                && push_operand (dest, GET_MODE (dest)))
6755                         return 0;
6756                     }
6757                 }
6758             }
6759
6760           if (GET_CODE (p) == CALL_INSN && CALL_INSN_FUNCTION_USAGE (p))
6761             {
6762               rtx link;
6763
6764               for (link = CALL_INSN_FUNCTION_USAGE (p); XEXP (link, 1) != 0;
6765                    link = XEXP (link, 1))
6766                 {
6767                   pat = XEXP (link, 0);
6768                   if (GET_CODE (pat) == CLOBBER)
6769                     {
6770                       rtx dest = SET_DEST (pat);
6771
6772                       if (GET_CODE (dest) == REG)
6773                         {
6774                           int xregno = REGNO (dest);
6775                           int xnregs
6776                             = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
6777
6778                           if (xregno < regno + nregs
6779                               && xregno + xnregs > regno)
6780                             return 0;
6781                           else if (xregno < valueno + valuenregs
6782                                    && xregno + xnregs > valueno)
6783                             return 0;
6784                           else if (goal_mem_addr_varies
6785                                    && reg_overlap_mentioned_for_reload_p (dest,
6786                                                                      goal))
6787                             return 0;
6788                         }
6789
6790                       else if (goal_mem && GET_CODE (dest) == MEM
6791                                && ! push_operand (dest, GET_MODE (dest)))
6792                         return 0;
6793                       else if (need_stable_sp
6794                                && push_operand (dest, GET_MODE (dest)))
6795                         return 0;
6796                     }
6797                 }
6798             }
6799
6800 #ifdef AUTO_INC_DEC
6801           /* If this insn auto-increments or auto-decrements
6802              either regno or valueno, return 0 now.
6803              If GOAL is a memory ref and its address is not constant,
6804              and this insn P increments a register used in GOAL, return 0.  */
6805           {
6806             rtx link;
6807
6808             for (link = REG_NOTES (p); link; link = XEXP (link, 1))
6809               if (REG_NOTE_KIND (link) == REG_INC
6810                   && GET_CODE (XEXP (link, 0)) == REG)
6811                 {
6812                   int incno = REGNO (XEXP (link, 0));
6813                   if (incno < regno + nregs && incno >= regno)
6814                     return 0;
6815                   if (incno < valueno + valuenregs && incno >= valueno)
6816                     return 0;
6817                   if (goal_mem_addr_varies
6818                       && reg_overlap_mentioned_for_reload_p (XEXP (link, 0),
6819                                                              goal))
6820                     return 0;
6821                 }
6822           }
6823 #endif
6824         }
6825     }
6826 }
6827 \f
6828 /* Find a place where INCED appears in an increment or decrement operator
6829    within X, and return the amount INCED is incremented or decremented by.
6830    The value is always positive.  */
6831
6832 static int
6833 find_inc_amount (x, inced)
6834      rtx x, inced;
6835 {
6836   enum rtx_code code = GET_CODE (x);
6837   const char *fmt;
6838   int i;
6839
6840   if (code == MEM)
6841     {
6842       rtx addr = XEXP (x, 0);
6843       if ((GET_CODE (addr) == PRE_DEC
6844            || GET_CODE (addr) == POST_DEC
6845            || GET_CODE (addr) == PRE_INC
6846            || GET_CODE (addr) == POST_INC)
6847           && XEXP (addr, 0) == inced)
6848         return GET_MODE_SIZE (GET_MODE (x));
6849       else if ((GET_CODE (addr) == PRE_MODIFY
6850                 || GET_CODE (addr) == POST_MODIFY)
6851                && GET_CODE (XEXP (addr, 1)) == PLUS
6852                && XEXP (addr, 0) == XEXP (XEXP (addr, 1), 0)
6853                && XEXP (addr, 0) == inced
6854                && GET_CODE (XEXP (XEXP (addr, 1), 1)) == CONST_INT)
6855         {
6856           i = INTVAL (XEXP (XEXP (addr, 1), 1));
6857           return i < 0 ? -i : i;
6858         }
6859     }
6860
6861   fmt = GET_RTX_FORMAT (code);
6862   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
6863     {
6864       if (fmt[i] == 'e')
6865         {
6866           int tem = find_inc_amount (XEXP (x, i), inced);
6867           if (tem != 0)
6868             return tem;
6869         }
6870       if (fmt[i] == 'E')
6871         {
6872           int j;
6873           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
6874             {
6875               int tem = find_inc_amount (XVECEXP (x, i, j), inced);
6876               if (tem != 0)
6877                 return tem;
6878             }
6879         }
6880     }
6881
6882   return 0;
6883 }
6884 \f
6885 /* Return 1 if register REGNO is the subject of a clobber in insn INSN.
6886    If SETS is nonzero, also consider SETs.  */
6887
6888 int
6889 regno_clobbered_p (regno, insn, mode, sets)
6890      unsigned int regno;
6891      rtx insn;
6892      enum machine_mode mode;
6893      int sets;
6894 {
6895   unsigned int nregs = HARD_REGNO_NREGS (regno, mode);
6896   unsigned int endregno = regno + nregs;
6897
6898   if ((GET_CODE (PATTERN (insn)) == CLOBBER
6899        || (sets && GET_CODE (PATTERN (insn)) == SET))
6900       && GET_CODE (XEXP (PATTERN (insn), 0)) == REG)
6901     {
6902       unsigned int test = REGNO (XEXP (PATTERN (insn), 0));
6903
6904       return test >= regno && test < endregno;
6905     }
6906
6907   if (GET_CODE (PATTERN (insn)) == PARALLEL)
6908     {
6909       int i = XVECLEN (PATTERN (insn), 0) - 1;
6910
6911       for (; i >= 0; i--)
6912         {
6913           rtx elt = XVECEXP (PATTERN (insn), 0, i);
6914           if ((GET_CODE (elt) == CLOBBER
6915                || (sets && GET_CODE (PATTERN (insn)) == SET))
6916               && GET_CODE (XEXP (elt, 0)) == REG)
6917             {
6918               unsigned int test = REGNO (XEXP (elt, 0));
6919
6920               if (test >= regno && test < endregno)
6921                 return 1;
6922             }
6923         }
6924     }
6925
6926   return 0;
6927 }
6928
6929 /* Find the low part, with mode MODE, of a hard regno RELOADREG.  */
6930 rtx
6931 reload_adjust_reg_for_mode (reloadreg, mode)
6932      rtx reloadreg;
6933      enum machine_mode mode;
6934 {
6935   int regno;
6936
6937   if (GET_MODE (reloadreg) == mode)
6938     return reloadreg;
6939
6940   regno = REGNO (reloadreg);
6941
6942   if (WORDS_BIG_ENDIAN)
6943     regno += HARD_REGNO_NREGS (regno, GET_MODE (reloadreg))
6944       - HARD_REGNO_NREGS (regno, mode);
6945
6946   return gen_rtx_REG (mode, regno);
6947 }
6948
6949 static const char *const reload_when_needed_name[] =
6950 {
6951   "RELOAD_FOR_INPUT",
6952   "RELOAD_FOR_OUTPUT",
6953   "RELOAD_FOR_INSN",
6954   "RELOAD_FOR_INPUT_ADDRESS",
6955   "RELOAD_FOR_INPADDR_ADDRESS",
6956   "RELOAD_FOR_OUTPUT_ADDRESS",
6957   "RELOAD_FOR_OUTADDR_ADDRESS",
6958   "RELOAD_FOR_OPERAND_ADDRESS",
6959   "RELOAD_FOR_OPADDR_ADDR",
6960   "RELOAD_OTHER",
6961   "RELOAD_FOR_OTHER_ADDRESS"
6962 };
6963
6964 static const char * const reg_class_names[] = REG_CLASS_NAMES;
6965
6966 /* These functions are used to print the variables set by 'find_reloads' */
6967
6968 void
6969 debug_reload_to_stream (f)
6970      FILE *f;
6971 {
6972   int r;
6973   const char *prefix;
6974
6975   if (! f)
6976     f = stderr;
6977   for (r = 0; r < n_reloads; r++)
6978     {
6979       fprintf (f, "Reload %d: ", r);
6980
6981       if (rld[r].in != 0)
6982         {
6983           fprintf (f, "reload_in (%s) = ",
6984                    GET_MODE_NAME (rld[r].inmode));
6985           print_inline_rtx (f, rld[r].in, 24);
6986           fprintf (f, "\n\t");
6987         }
6988
6989       if (rld[r].out != 0)
6990         {
6991           fprintf (f, "reload_out (%s) = ",
6992                    GET_MODE_NAME (rld[r].outmode));
6993           print_inline_rtx (f, rld[r].out, 24);
6994           fprintf (f, "\n\t");
6995         }
6996
6997       fprintf (f, "%s, ", reg_class_names[(int) rld[r].class]);
6998
6999       fprintf (f, "%s (opnum = %d)",
7000                reload_when_needed_name[(int) rld[r].when_needed],
7001                rld[r].opnum);
7002
7003       if (rld[r].optional)
7004         fprintf (f, ", optional");
7005
7006       if (rld[r].nongroup)
7007         fprintf (f, ", nongroup");
7008
7009       if (rld[r].inc != 0)
7010         fprintf (f, ", inc by %d", rld[r].inc);
7011
7012       if (rld[r].nocombine)
7013         fprintf (f, ", can't combine");
7014
7015       if (rld[r].secondary_p)
7016         fprintf (f, ", secondary_reload_p");
7017
7018       if (rld[r].in_reg != 0)
7019         {
7020           fprintf (f, "\n\treload_in_reg: ");
7021           print_inline_rtx (f, rld[r].in_reg, 24);
7022         }
7023
7024       if (rld[r].out_reg != 0)
7025         {
7026           fprintf (f, "\n\treload_out_reg: ");
7027           print_inline_rtx (f, rld[r].out_reg, 24);
7028         }
7029
7030       if (rld[r].reg_rtx != 0)
7031         {
7032           fprintf (f, "\n\treload_reg_rtx: ");
7033           print_inline_rtx (f, rld[r].reg_rtx, 24);
7034         }
7035
7036       prefix = "\n\t";
7037       if (rld[r].secondary_in_reload != -1)
7038         {
7039           fprintf (f, "%ssecondary_in_reload = %d",
7040                    prefix, rld[r].secondary_in_reload);
7041           prefix = ", ";
7042         }
7043
7044       if (rld[r].secondary_out_reload != -1)
7045         fprintf (f, "%ssecondary_out_reload = %d\n",
7046                  prefix, rld[r].secondary_out_reload);
7047
7048       prefix = "\n\t";
7049       if (rld[r].secondary_in_icode != CODE_FOR_nothing)
7050         {
7051           fprintf (f, "%ssecondary_in_icode = %s", prefix,
7052                    insn_data[rld[r].secondary_in_icode].name);
7053           prefix = ", ";
7054         }
7055
7056       if (rld[r].secondary_out_icode != CODE_FOR_nothing)
7057         fprintf (f, "%ssecondary_out_icode = %s", prefix,
7058                  insn_data[rld[r].secondary_out_icode].name);
7059
7060       fprintf (f, "\n");
7061     }
7062 }
7063
7064 void
7065 debug_reload ()
7066 {
7067   debug_reload_to_stream (stderr);
7068 }