gcc/reload.c

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