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