Merge branch 'vendor/GCC44'
[dragonfly.git] / contrib / gcc-4.4 / gcc / reload.c
1 /* Search an insn for pseudo regs that must be in hard regs and are not.
2    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4    Free Software Foundation, Inc.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
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    init_reload actually has to be called earlier anyway.
31
32    To scan an insn, call `find_reloads'.  This does two things:
33    1. sets up tables describing which values must be reloaded
34    for this insn, and what kind of hard regs they must be reloaded into;
35    2. optionally record the locations where those values appear in
36    the data, so they can be replaced properly later.
37    This is done only if the second arg to `find_reloads' is nonzero.
38
39    The third arg to `find_reloads' specifies the number of levels
40    of indirect addressing supported by the machine.  If it is zero,
41    indirect addressing is not valid.  If it is one, (MEM (REG n))
42    is valid even if (REG n) did not get a hard register; if it is two,
43    (MEM (MEM (REG n))) is also valid even if (REG n) did not get a
44    hard register, and similarly for higher values.
45
46    Then you must choose the hard regs to reload those pseudo regs into,
47    and generate appropriate load insns before this insn and perhaps
48    also store insns after this insn.  Set up the array `reload_reg_rtx'
49    to contain the REG rtx's for the registers you used.  In some
50    cases `find_reloads' will return a nonzero value in `reload_reg_rtx'
51    for certain reloads.  Then that tells you which register to use,
52    so you do not need to allocate one.  But you still do need to add extra
53    instructions to copy the value into and out of that register.
54
55    Finally you must call `subst_reloads' to substitute the reload reg rtx's
56    into the locations already recorded.
57
58 NOTE SIDE EFFECTS:
59
60    find_reloads can alter the operands of the instruction it is called on.
61
62    1. Two operands of any sort may be interchanged, if they are in a
63    commutative instruction.
64    This happens only if find_reloads thinks the instruction will compile
65    better that way.
66
67    2. Pseudo-registers that are equivalent to constants are replaced
68    with those constants if they are not in hard registers.
69
70 1 happens every time find_reloads is called.
71 2 happens only when REPLACE is 1, which is only when
72 actually doing the reloads, not when just counting them.
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 /* We do not enable this with ENABLE_CHECKING, since it is awfully slow.  */
91 #undef DEBUG_RELOAD
92
93 #include "config.h"
94 #include "system.h"
95 #include "coretypes.h"
96 #include "tm.h"
97 #include "rtl.h"
98 #include "tm_p.h"
99 #include "insn-config.h"
100 #include "expr.h"
101 #include "optabs.h"
102 #include "recog.h"
103 #include "reload.h"
104 #include "regs.h"
105 #include "addresses.h"
106 #include "hard-reg-set.h"
107 #include "flags.h"
108 #include "real.h"
109 #include "output.h"
110 #include "function.h"
111 #include "toplev.h"
112 #include "params.h"
113 #include "target.h"
114 #include "df.h"
115
116 /* True if X is a constant that can be forced into the constant pool.  */
117 #define CONST_POOL_OK_P(X)                      \
118   (CONSTANT_P (X)                               \
119    && GET_CODE (X) != HIGH                      \
120    && !targetm.cannot_force_const_mem (X))
121
122 /* True if C is a non-empty register class that has too few registers
123    to be safely used as a reload target class.  */
124 #define SMALL_REGISTER_CLASS_P(C) \
125   (reg_class_size [(C)] == 1 \
126    || (reg_class_size [(C)] >= 1 && CLASS_LIKELY_SPILLED_P (C)))
127
128 \f
129 /* All reloads of the current insn are recorded here.  See reload.h for
130    comments.  */
131 int n_reloads;
132 struct reload rld[MAX_RELOADS];
133
134 /* All the "earlyclobber" operands of the current insn
135    are recorded here.  */
136 int n_earlyclobbers;
137 rtx reload_earlyclobbers[MAX_RECOG_OPERANDS];
138
139 int reload_n_operands;
140
141 /* Replacing reloads.
142
143    If `replace_reloads' is nonzero, then as each reload is recorded
144    an entry is made for it in the table `replacements'.
145    Then later `subst_reloads' can look through that table and
146    perform all the replacements needed.  */
147
148 /* Nonzero means record the places to replace.  */
149 static int replace_reloads;
150
151 /* Each replacement is recorded with a structure like this.  */
152 struct replacement
153 {
154   rtx *where;                   /* Location to store in */
155   rtx *subreg_loc;              /* Location of SUBREG if WHERE is inside
156                                    a SUBREG; 0 otherwise.  */
157   int what;                     /* which reload this is for */
158   enum machine_mode mode;       /* mode it must have */
159 };
160
161 static struct replacement replacements[MAX_RECOG_OPERANDS * ((MAX_REGS_PER_ADDRESS * 2) + 1)];
162
163 /* Number of replacements currently recorded.  */
164 static int n_replacements;
165
166 /* Used to track what is modified by an operand.  */
167 struct decomposition
168 {
169   int reg_flag;         /* Nonzero if referencing a register.  */
170   int safe;             /* Nonzero if this can't conflict with anything.  */
171   rtx base;             /* Base address for MEM.  */
172   HOST_WIDE_INT start;  /* Starting offset or register number.  */
173   HOST_WIDE_INT end;    /* Ending offset or register number.  */
174 };
175
176 #ifdef SECONDARY_MEMORY_NEEDED
177
178 /* Save MEMs needed to copy from one class of registers to another.  One MEM
179    is used per mode, but normally only one or two modes are ever used.
180
181    We keep two versions, before and after register elimination.  The one
182    after register elimination is record separately for each operand.  This
183    is done in case the address is not valid to be sure that we separately
184    reload each.  */
185
186 static rtx secondary_memlocs[NUM_MACHINE_MODES];
187 static rtx secondary_memlocs_elim[NUM_MACHINE_MODES][MAX_RECOG_OPERANDS];
188 static int secondary_memlocs_elim_used = 0;
189 #endif
190
191 /* The instruction we are doing reloads for;
192    so we can test whether a register dies in it.  */
193 static rtx this_insn;
194
195 /* Nonzero if this instruction is a user-specified asm with operands.  */
196 static int this_insn_is_asm;
197
198 /* If hard_regs_live_known is nonzero,
199    we can tell which hard regs are currently live,
200    at least enough to succeed in choosing dummy reloads.  */
201 static int hard_regs_live_known;
202
203 /* Indexed by hard reg number,
204    element is nonnegative if hard reg has been spilled.
205    This vector is passed to `find_reloads' as an argument
206    and is not changed here.  */
207 static short *static_reload_reg_p;
208
209 /* Set to 1 in subst_reg_equivs if it changes anything.  */
210 static int subst_reg_equivs_changed;
211
212 /* On return from push_reload, holds the reload-number for the OUT
213    operand, which can be different for that from the input operand.  */
214 static int output_reloadnum;
215
216   /* Compare two RTX's.  */
217 #define MATCHES(x, y) \
218  (x == y || (x != 0 && (REG_P (x)                               \
219                         ? REG_P (y) && REGNO (x) == REGNO (y)   \
220                         : rtx_equal_p (x, y) && ! side_effects_p (x))))
221
222   /* Indicates if two reloads purposes are for similar enough things that we
223      can merge their reloads.  */
224 #define MERGABLE_RELOADS(when1, when2, op1, op2) \
225   ((when1) == RELOAD_OTHER || (when2) == RELOAD_OTHER   \
226    || ((when1) == (when2) && (op1) == (op2))            \
227    || ((when1) == RELOAD_FOR_INPUT && (when2) == RELOAD_FOR_INPUT) \
228    || ((when1) == RELOAD_FOR_OPERAND_ADDRESS            \
229        && (when2) == RELOAD_FOR_OPERAND_ADDRESS)        \
230    || ((when1) == RELOAD_FOR_OTHER_ADDRESS              \
231        && (when2) == RELOAD_FOR_OTHER_ADDRESS))
232
233   /* Nonzero if these two reload purposes produce RELOAD_OTHER when merged.  */
234 #define MERGE_TO_OTHER(when1, when2, op1, op2) \
235   ((when1) != (when2)                                   \
236    || ! ((op1) == (op2)                                 \
237          || (when1) == RELOAD_FOR_INPUT                 \
238          || (when1) == RELOAD_FOR_OPERAND_ADDRESS       \
239          || (when1) == RELOAD_FOR_OTHER_ADDRESS))
240
241   /* If we are going to reload an address, compute the reload type to
242      use.  */
243 #define ADDR_TYPE(type)                                 \
244   ((type) == RELOAD_FOR_INPUT_ADDRESS                   \
245    ? RELOAD_FOR_INPADDR_ADDRESS                         \
246    : ((type) == RELOAD_FOR_OUTPUT_ADDRESS               \
247       ? RELOAD_FOR_OUTADDR_ADDRESS                      \
248       : (type)))
249
250 static int push_secondary_reload (int, rtx, int, int, enum reg_class,
251                                   enum machine_mode, enum reload_type,
252                                   enum insn_code *, secondary_reload_info *);
253 static enum reg_class find_valid_class (enum machine_mode, enum machine_mode,
254                                         int, unsigned int);
255 static int reload_inner_reg_of_subreg (rtx, enum machine_mode, int);
256 static void push_replacement (rtx *, int, enum machine_mode);
257 static void dup_replacements (rtx *, rtx *);
258 static void combine_reloads (void);
259 static int find_reusable_reload (rtx *, rtx, enum reg_class,
260                                  enum reload_type, int, int);
261 static rtx find_dummy_reload (rtx, rtx, rtx *, rtx *, enum machine_mode,
262                               enum machine_mode, enum reg_class, int, int);
263 static int hard_reg_set_here_p (unsigned int, unsigned int, rtx);
264 static struct decomposition decompose (rtx);
265 static int immune_p (rtx, rtx, struct decomposition);
266 static bool alternative_allows_const_pool_ref (rtx, const char *, int);
267 static rtx find_reloads_toplev (rtx, int, enum reload_type, int, int, rtx,
268                                 int *);
269 static rtx make_memloc (rtx, int);
270 static int maybe_memory_address_p (enum machine_mode, rtx, rtx *);
271 static int find_reloads_address (enum machine_mode, rtx *, rtx, rtx *,
272                                  int, enum reload_type, int, rtx);
273 static rtx subst_reg_equivs (rtx, rtx);
274 static rtx subst_indexed_address (rtx);
275 static void update_auto_inc_notes (rtx, int, int);
276 static int find_reloads_address_1 (enum machine_mode, rtx, int,
277                                    enum rtx_code, enum rtx_code, rtx *,
278                                    int, enum reload_type,int, rtx);
279 static void find_reloads_address_part (rtx, rtx *, enum reg_class,
280                                        enum machine_mode, int,
281                                        enum reload_type, int);
282 static rtx find_reloads_subreg_address (rtx, int, int, enum reload_type,
283                                         int, rtx);
284 static void copy_replacements_1 (rtx *, rtx *, int);
285 static int find_inc_amount (rtx, rtx);
286 static int refers_to_mem_for_reload_p (rtx);
287 static int refers_to_regno_for_reload_p (unsigned int, unsigned int,
288                                          rtx, rtx *);
289
290 /* Add NEW to reg_equiv_alt_mem_list[REGNO] if it's not present in the
291    list yet.  */
292
293 static void
294 push_reg_equiv_alt_mem (int regno, rtx mem)
295 {
296   rtx it;
297
298   for (it = reg_equiv_alt_mem_list [regno]; it; it = XEXP (it, 1))
299     if (rtx_equal_p (XEXP (it, 0), mem))
300       return;
301
302   reg_equiv_alt_mem_list [regno]
303     = alloc_EXPR_LIST (REG_EQUIV, mem,
304                        reg_equiv_alt_mem_list [regno]);
305 }
306 \f
307 /* Determine if any secondary reloads are needed for loading (if IN_P is
308    nonzero) or storing (if IN_P is zero) X to or from a reload register of
309    register class RELOAD_CLASS in mode RELOAD_MODE.  If secondary reloads
310    are needed, push them.
311
312    Return the reload number of the secondary reload we made, or -1 if
313    we didn't need one.  *PICODE is set to the insn_code to use if we do
314    need a secondary reload.  */
315
316 static int
317 push_secondary_reload (int in_p, rtx x, int opnum, int optional,
318                        enum reg_class reload_class,
319                        enum machine_mode reload_mode, enum reload_type type,
320                        enum insn_code *picode, secondary_reload_info *prev_sri)
321 {
322   enum reg_class rclass = NO_REGS;
323   enum reg_class scratch_class;
324   enum machine_mode mode = reload_mode;
325   enum insn_code icode = CODE_FOR_nothing;
326   enum insn_code t_icode = CODE_FOR_nothing;
327   enum reload_type secondary_type;
328   int s_reload, t_reload = -1;
329   const char *scratch_constraint;
330   char letter;
331   secondary_reload_info sri;
332
333   if (type == RELOAD_FOR_INPUT_ADDRESS
334       || type == RELOAD_FOR_OUTPUT_ADDRESS
335       || type == RELOAD_FOR_INPADDR_ADDRESS
336       || type == RELOAD_FOR_OUTADDR_ADDRESS)
337     secondary_type = type;
338   else
339     secondary_type = in_p ? RELOAD_FOR_INPUT_ADDRESS : RELOAD_FOR_OUTPUT_ADDRESS;
340
341   *picode = CODE_FOR_nothing;
342
343   /* If X is a paradoxical SUBREG, use the inner value to determine both the
344      mode and object being reloaded.  */
345   if (GET_CODE (x) == SUBREG
346       && (GET_MODE_SIZE (GET_MODE (x))
347           > GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))))
348     {
349       x = SUBREG_REG (x);
350       reload_mode = GET_MODE (x);
351     }
352
353   /* If X is a pseudo-register that has an equivalent MEM (actually, if it
354      is still a pseudo-register by now, it *must* have an equivalent MEM
355      but we don't want to assume that), use that equivalent when seeing if
356      a secondary reload is needed since whether or not a reload is needed
357      might be sensitive to the form of the MEM.  */
358
359   if (REG_P (x) && REGNO (x) >= FIRST_PSEUDO_REGISTER
360       && reg_equiv_mem[REGNO (x)] != 0)
361     x = reg_equiv_mem[REGNO (x)];
362
363   sri.icode = CODE_FOR_nothing;
364   sri.prev_sri = prev_sri;
365   rclass = targetm.secondary_reload (in_p, x, reload_class, reload_mode, &sri);
366   icode = sri.icode;
367
368   /* If we don't need any secondary registers, done.  */
369   if (rclass == NO_REGS && icode == CODE_FOR_nothing)
370     return -1;
371
372   if (rclass != NO_REGS)
373     t_reload = push_secondary_reload (in_p, x, opnum, optional, rclass,
374                                       reload_mode, type, &t_icode, &sri);
375
376   /* If we will be using an insn, the secondary reload is for a
377      scratch register.  */
378
379   if (icode != CODE_FOR_nothing)
380     {
381       /* If IN_P is nonzero, the reload register will be the output in
382          operand 0.  If IN_P is zero, the reload register will be the input
383          in operand 1.  Outputs should have an initial "=", which we must
384          skip.  */
385
386       /* ??? It would be useful to be able to handle only two, or more than
387          three, operands, but for now we can only handle the case of having
388          exactly three: output, input and one temp/scratch.  */
389       gcc_assert (insn_data[(int) icode].n_operands == 3);
390
391       /* ??? We currently have no way to represent a reload that needs
392          an icode to reload from an intermediate tertiary reload register.
393          We should probably have a new field in struct reload to tag a
394          chain of scratch operand reloads onto.   */
395       gcc_assert (rclass == NO_REGS);
396
397       scratch_constraint = insn_data[(int) icode].operand[2].constraint;
398       gcc_assert (*scratch_constraint == '=');
399       scratch_constraint++;
400       if (*scratch_constraint == '&')
401         scratch_constraint++;
402       letter = *scratch_constraint;
403       scratch_class = (letter == 'r' ? GENERAL_REGS
404                        : REG_CLASS_FROM_CONSTRAINT ((unsigned char) letter,
405                                                    scratch_constraint));
406
407       rclass = scratch_class;
408       mode = insn_data[(int) icode].operand[2].mode;
409     }
410
411   /* This case isn't valid, so fail.  Reload is allowed to use the same
412      register for RELOAD_FOR_INPUT_ADDRESS and RELOAD_FOR_INPUT reloads, but
413      in the case of a secondary register, we actually need two different
414      registers for correct code.  We fail here to prevent the possibility of
415      silently generating incorrect code later.
416
417      The convention is that secondary input reloads are valid only if the
418      secondary_class is different from class.  If you have such a case, you
419      can not use secondary reloads, you must work around the problem some
420      other way.
421
422      Allow this when a reload_in/out pattern is being used.  I.e. assume
423      that the generated code handles this case.  */
424
425   gcc_assert (!in_p || rclass != reload_class || icode != CODE_FOR_nothing
426               || t_icode != CODE_FOR_nothing);
427
428   /* See if we can reuse an existing secondary reload.  */
429   for (s_reload = 0; s_reload < n_reloads; s_reload++)
430     if (rld[s_reload].secondary_p
431         && (reg_class_subset_p (rclass, rld[s_reload].rclass)
432             || reg_class_subset_p (rld[s_reload].rclass, rclass))
433         && ((in_p && rld[s_reload].inmode == mode)
434             || (! in_p && rld[s_reload].outmode == mode))
435         && ((in_p && rld[s_reload].secondary_in_reload == t_reload)
436             || (! in_p && rld[s_reload].secondary_out_reload == t_reload))
437         && ((in_p && rld[s_reload].secondary_in_icode == t_icode)
438             || (! in_p && rld[s_reload].secondary_out_icode == t_icode))
439         && (SMALL_REGISTER_CLASS_P (rclass) || SMALL_REGISTER_CLASSES)
440         && MERGABLE_RELOADS (secondary_type, rld[s_reload].when_needed,
441                              opnum, rld[s_reload].opnum))
442       {
443         if (in_p)
444           rld[s_reload].inmode = mode;
445         if (! in_p)
446           rld[s_reload].outmode = mode;
447
448         if (reg_class_subset_p (rclass, rld[s_reload].rclass))
449           rld[s_reload].rclass = rclass;
450
451         rld[s_reload].opnum = MIN (rld[s_reload].opnum, opnum);
452         rld[s_reload].optional &= optional;
453         rld[s_reload].secondary_p = 1;
454         if (MERGE_TO_OTHER (secondary_type, rld[s_reload].when_needed,
455                             opnum, rld[s_reload].opnum))
456           rld[s_reload].when_needed = RELOAD_OTHER;
457
458         break;
459       }
460
461   if (s_reload == n_reloads)
462     {
463 #ifdef SECONDARY_MEMORY_NEEDED
464       /* If we need a memory location to copy between the two reload regs,
465          set it up now.  Note that we do the input case before making
466          the reload and the output case after.  This is due to the
467          way reloads are output.  */
468
469       if (in_p && icode == CODE_FOR_nothing
470           && SECONDARY_MEMORY_NEEDED (rclass, reload_class, mode))
471         {
472           get_secondary_mem (x, reload_mode, opnum, type);
473
474           /* We may have just added new reloads.  Make sure we add
475              the new reload at the end.  */
476           s_reload = n_reloads;
477         }
478 #endif
479
480       /* We need to make a new secondary reload for this register class.  */
481       rld[s_reload].in = rld[s_reload].out = 0;
482       rld[s_reload].rclass = rclass;
483
484       rld[s_reload].inmode = in_p ? mode : VOIDmode;
485       rld[s_reload].outmode = ! in_p ? mode : VOIDmode;
486       rld[s_reload].reg_rtx = 0;
487       rld[s_reload].optional = optional;
488       rld[s_reload].inc = 0;
489       /* Maybe we could combine these, but it seems too tricky.  */
490       rld[s_reload].nocombine = 1;
491       rld[s_reload].in_reg = 0;
492       rld[s_reload].out_reg = 0;
493       rld[s_reload].opnum = opnum;
494       rld[s_reload].when_needed = secondary_type;
495       rld[s_reload].secondary_in_reload = in_p ? t_reload : -1;
496       rld[s_reload].secondary_out_reload = ! in_p ? t_reload : -1;
497       rld[s_reload].secondary_in_icode = in_p ? t_icode : CODE_FOR_nothing;
498       rld[s_reload].secondary_out_icode
499         = ! in_p ? t_icode : CODE_FOR_nothing;
500       rld[s_reload].secondary_p = 1;
501
502       n_reloads++;
503
504 #ifdef SECONDARY_MEMORY_NEEDED
505       if (! in_p && icode == CODE_FOR_nothing
506           && SECONDARY_MEMORY_NEEDED (reload_class, rclass, mode))
507         get_secondary_mem (x, mode, opnum, type);
508 #endif
509     }
510
511   *picode = icode;
512   return s_reload;
513 }
514
515 /* If a secondary reload is needed, return its class.  If both an intermediate
516    register and a scratch register is needed, we return the class of the
517    intermediate register.  */
518 enum reg_class
519 secondary_reload_class (bool in_p, enum reg_class rclass,
520                         enum machine_mode mode, rtx x)
521 {
522   enum insn_code icode;
523   secondary_reload_info sri;
524
525   sri.icode = CODE_FOR_nothing;
526   sri.prev_sri = NULL;
527   rclass = targetm.secondary_reload (in_p, x, rclass, mode, &sri);
528   icode = sri.icode;
529
530   /* If there are no secondary reloads at all, we return NO_REGS.
531      If an intermediate register is needed, we return its class.  */
532   if (icode == CODE_FOR_nothing || rclass != NO_REGS)
533     return rclass;
534
535   /* No intermediate register is needed, but we have a special reload
536      pattern, which we assume for now needs a scratch register.  */
537   return scratch_reload_class (icode);
538 }
539
540 /* ICODE is the insn_code of a reload pattern.  Check that it has exactly
541    three operands, verify that operand 2 is an output operand, and return
542    its register class.
543    ??? We'd like to be able to handle any pattern with at least 2 operands,
544    for zero or more scratch registers, but that needs more infrastructure.  */
545 enum reg_class
546 scratch_reload_class (enum insn_code icode)
547 {
548   const char *scratch_constraint;
549   char scratch_letter;
550   enum reg_class rclass;
551
552   gcc_assert (insn_data[(int) icode].n_operands == 3);
553   scratch_constraint = insn_data[(int) icode].operand[2].constraint;
554   gcc_assert (*scratch_constraint == '=');
555   scratch_constraint++;
556   if (*scratch_constraint == '&')
557     scratch_constraint++;
558   scratch_letter = *scratch_constraint;
559   if (scratch_letter == 'r')
560     return GENERAL_REGS;
561   rclass = REG_CLASS_FROM_CONSTRAINT ((unsigned char) scratch_letter,
562                                      scratch_constraint);
563   gcc_assert (rclass != NO_REGS);
564   return rclass;
565 }
566 \f
567 #ifdef SECONDARY_MEMORY_NEEDED
568
569 /* Return a memory location that will be used to copy X in mode MODE.
570    If we haven't already made a location for this mode in this insn,
571    call find_reloads_address on the location being returned.  */
572
573 rtx
574 get_secondary_mem (rtx x ATTRIBUTE_UNUSED, enum machine_mode mode,
575                    int opnum, enum reload_type type)
576 {
577   rtx loc;
578   int mem_valid;
579
580   /* By default, if MODE is narrower than a word, widen it to a word.
581      This is required because most machines that require these memory
582      locations do not support short load and stores from all registers
583      (e.g., FP registers).  */
584
585 #ifdef SECONDARY_MEMORY_NEEDED_MODE
586   mode = SECONDARY_MEMORY_NEEDED_MODE (mode);
587 #else
588   if (GET_MODE_BITSIZE (mode) < BITS_PER_WORD && INTEGRAL_MODE_P (mode))
589     mode = mode_for_size (BITS_PER_WORD, GET_MODE_CLASS (mode), 0);
590 #endif
591
592   /* If we already have made a MEM for this operand in MODE, return it.  */
593   if (secondary_memlocs_elim[(int) mode][opnum] != 0)
594     return secondary_memlocs_elim[(int) mode][opnum];
595
596   /* If this is the first time we've tried to get a MEM for this mode,
597      allocate a new one.  `something_changed' in reload will get set
598      by noticing that the frame size has changed.  */
599
600   if (secondary_memlocs[(int) mode] == 0)
601     {
602 #ifdef SECONDARY_MEMORY_NEEDED_RTX
603       secondary_memlocs[(int) mode] = SECONDARY_MEMORY_NEEDED_RTX (mode);
604 #else
605       secondary_memlocs[(int) mode]
606         = assign_stack_local (mode, GET_MODE_SIZE (mode), 0);
607 #endif
608     }
609
610   /* Get a version of the address doing any eliminations needed.  If that
611      didn't give us a new MEM, make a new one if it isn't valid.  */
612
613   loc = eliminate_regs (secondary_memlocs[(int) mode], VOIDmode, NULL_RTX);
614   mem_valid = strict_memory_address_p (mode, XEXP (loc, 0));
615
616   if (! mem_valid && loc == secondary_memlocs[(int) mode])
617     loc = copy_rtx (loc);
618
619   /* The only time the call below will do anything is if the stack
620      offset is too large.  In that case IND_LEVELS doesn't matter, so we
621      can just pass a zero.  Adjust the type to be the address of the
622      corresponding object.  If the address was valid, save the eliminated
623      address.  If it wasn't valid, we need to make a reload each time, so
624      don't save it.  */
625
626   if (! mem_valid)
627     {
628       type =  (type == RELOAD_FOR_INPUT ? RELOAD_FOR_INPUT_ADDRESS
629                : type == RELOAD_FOR_OUTPUT ? RELOAD_FOR_OUTPUT_ADDRESS
630                : RELOAD_OTHER);
631
632       find_reloads_address (mode, &loc, XEXP (loc, 0), &XEXP (loc, 0),
633                             opnum, type, 0, 0);
634     }
635
636   secondary_memlocs_elim[(int) mode][opnum] = loc;
637   if (secondary_memlocs_elim_used <= (int)mode)
638     secondary_memlocs_elim_used = (int)mode + 1;
639   return loc;
640 }
641
642 /* Clear any secondary memory locations we've made.  */
643
644 void
645 clear_secondary_mem (void)
646 {
647   memset (secondary_memlocs, 0, sizeof secondary_memlocs);
648 }
649 #endif /* SECONDARY_MEMORY_NEEDED */
650 \f
651
652 /* Find the largest class which has at least one register valid in
653    mode INNER, and which for every such register, that register number
654    plus N is also valid in OUTER (if in range) and is cheap to move
655    into REGNO.  Such a class must exist.  */
656
657 static enum reg_class
658 find_valid_class (enum machine_mode outer ATTRIBUTE_UNUSED,
659                   enum machine_mode inner ATTRIBUTE_UNUSED, int n,
660                   unsigned int dest_regno ATTRIBUTE_UNUSED)
661 {
662   int best_cost = -1;
663   int rclass;
664   int regno;
665   enum reg_class best_class = NO_REGS;
666   enum reg_class dest_class ATTRIBUTE_UNUSED = REGNO_REG_CLASS (dest_regno);
667   unsigned int best_size = 0;
668   int cost;
669
670   for (rclass = 1; rclass < N_REG_CLASSES; rclass++)
671     {
672       int bad = 0;
673       int good = 0;
674       for (regno = 0; regno < FIRST_PSEUDO_REGISTER - n && ! bad; regno++)
675         if (TEST_HARD_REG_BIT (reg_class_contents[rclass], regno))
676           {
677             if (HARD_REGNO_MODE_OK (regno, inner))
678               {
679                 good = 1;
680                 if (! TEST_HARD_REG_BIT (reg_class_contents[rclass], regno + n)
681                     || ! HARD_REGNO_MODE_OK (regno + n, outer))
682                   bad = 1;
683               }
684           }
685
686       if (bad || !good)
687         continue;
688       cost = REGISTER_MOVE_COST (outer, rclass, dest_class);
689
690       if ((reg_class_size[rclass] > best_size
691            && (best_cost < 0 || best_cost >= cost))
692           || best_cost > cost)
693         {
694           best_class = rclass;
695           best_size = reg_class_size[rclass];
696           best_cost = REGISTER_MOVE_COST (outer, rclass, dest_class);
697         }
698     }
699
700   gcc_assert (best_size != 0);
701
702   return best_class;
703 }
704 \f
705 /* Return the number of a previously made reload that can be combined with
706    a new one, or n_reloads if none of the existing reloads can be used.
707    OUT, RCLASS, TYPE and OPNUM are the same arguments as passed to
708    push_reload, they determine the kind of the new reload that we try to
709    combine.  P_IN points to the corresponding value of IN, which can be
710    modified by this function.
711    DONT_SHARE is nonzero if we can't share any input-only reload for IN.  */
712
713 static int
714 find_reusable_reload (rtx *p_in, rtx out, enum reg_class rclass,
715                       enum reload_type type, int opnum, int dont_share)
716 {
717   rtx in = *p_in;
718   int i;
719   /* We can't merge two reloads if the output of either one is
720      earlyclobbered.  */
721
722   if (earlyclobber_operand_p (out))
723     return n_reloads;
724
725   /* We can use an existing reload if the class is right
726      and at least one of IN and OUT is a match
727      and the other is at worst neutral.
728      (A zero compared against anything is neutral.)
729
730      If SMALL_REGISTER_CLASSES, don't use existing reloads unless they are
731      for the same thing since that can cause us to need more reload registers
732      than we otherwise would.  */
733
734   for (i = 0; i < n_reloads; i++)
735     if ((reg_class_subset_p (rclass, rld[i].rclass)
736          || reg_class_subset_p (rld[i].rclass, rclass))
737         /* If the existing reload has a register, it must fit our class.  */
738         && (rld[i].reg_rtx == 0
739             || TEST_HARD_REG_BIT (reg_class_contents[(int) rclass],
740                                   true_regnum (rld[i].reg_rtx)))
741         && ((in != 0 && MATCHES (rld[i].in, in) && ! dont_share
742              && (out == 0 || rld[i].out == 0 || MATCHES (rld[i].out, out)))
743             || (out != 0 && MATCHES (rld[i].out, out)
744                 && (in == 0 || rld[i].in == 0 || MATCHES (rld[i].in, in))))
745         && (rld[i].out == 0 || ! earlyclobber_operand_p (rld[i].out))
746         && (SMALL_REGISTER_CLASS_P (rclass) || SMALL_REGISTER_CLASSES)
747         && MERGABLE_RELOADS (type, rld[i].when_needed, opnum, rld[i].opnum))
748       return i;
749
750   /* Reloading a plain reg for input can match a reload to postincrement
751      that reg, since the postincrement's value is the right value.
752      Likewise, it can match a preincrement reload, since we regard
753      the preincrementation as happening before any ref in this insn
754      to that register.  */
755   for (i = 0; i < n_reloads; i++)
756     if ((reg_class_subset_p (rclass, rld[i].rclass)
757          || reg_class_subset_p (rld[i].rclass, rclass))
758         /* If the existing reload has a register, it must fit our
759            class.  */
760         && (rld[i].reg_rtx == 0
761             || TEST_HARD_REG_BIT (reg_class_contents[(int) rclass],
762                                   true_regnum (rld[i].reg_rtx)))
763         && out == 0 && rld[i].out == 0 && rld[i].in != 0
764         && ((REG_P (in)
765              && GET_RTX_CLASS (GET_CODE (rld[i].in)) == RTX_AUTOINC
766              && MATCHES (XEXP (rld[i].in, 0), in))
767             || (REG_P (rld[i].in)
768                 && GET_RTX_CLASS (GET_CODE (in)) == RTX_AUTOINC
769                 && MATCHES (XEXP (in, 0), rld[i].in)))
770         && (rld[i].out == 0 || ! earlyclobber_operand_p (rld[i].out))
771         && (SMALL_REGISTER_CLASS_P (rclass) || SMALL_REGISTER_CLASSES)
772         && MERGABLE_RELOADS (type, rld[i].when_needed,
773                              opnum, rld[i].opnum))
774       {
775         /* Make sure reload_in ultimately has the increment,
776            not the plain register.  */
777         if (REG_P (in))
778           *p_in = rld[i].in;
779         return i;
780       }
781   return n_reloads;
782 }
783
784 /* Return nonzero if X is a SUBREG which will require reloading of its
785    SUBREG_REG expression.  */
786
787 static int
788 reload_inner_reg_of_subreg (rtx x, enum machine_mode mode, int output)
789 {
790   rtx inner;
791
792   /* Only SUBREGs are problematical.  */
793   if (GET_CODE (x) != SUBREG)
794     return 0;
795
796   inner = SUBREG_REG (x);
797
798   /* If INNER is a constant or PLUS, then INNER must be reloaded.  */
799   if (CONSTANT_P (inner) || GET_CODE (inner) == PLUS)
800     return 1;
801
802   /* If INNER is not a hard register, then INNER will not need to
803      be reloaded.  */
804   if (!REG_P (inner)
805       || REGNO (inner) >= FIRST_PSEUDO_REGISTER)
806     return 0;
807
808   /* If INNER is not ok for MODE, then INNER will need reloading.  */
809   if (! HARD_REGNO_MODE_OK (subreg_regno (x), mode))
810     return 1;
811
812   /* If the outer part is a word or smaller, INNER larger than a
813      word and the number of regs for INNER is not the same as the
814      number of words in INNER, then INNER will need reloading.  */
815   return (GET_MODE_SIZE (mode) <= UNITS_PER_WORD
816           && output
817           && GET_MODE_SIZE (GET_MODE (inner)) > UNITS_PER_WORD
818           && ((GET_MODE_SIZE (GET_MODE (inner)) / UNITS_PER_WORD)
819               != (int) hard_regno_nregs[REGNO (inner)][GET_MODE (inner)]));
820 }
821
822 /* Return nonzero if IN can be reloaded into REGNO with mode MODE without
823    requiring an extra reload register.  The caller has already found that
824    IN contains some reference to REGNO, so check that we can produce the
825    new value in a single step.  E.g. if we have
826    (set (reg r13) (plus (reg r13) (const int 1))), and there is an
827    instruction that adds one to a register, this should succeed.
828    However, if we have something like
829    (set (reg r13) (plus (reg r13) (const int 999))), and the constant 999
830    needs to be loaded into a register first, we need a separate reload
831    register.
832    Such PLUS reloads are generated by find_reload_address_part.
833    The out-of-range PLUS expressions are usually introduced in the instruction
834    patterns by register elimination and substituting pseudos without a home
835    by their function-invariant equivalences.  */
836 static int
837 can_reload_into (rtx in, int regno, enum machine_mode mode)
838 {
839   rtx dst, test_insn;
840   int r = 0;
841   struct recog_data save_recog_data;
842
843   /* For matching constraints, we often get notional input reloads where
844      we want to use the original register as the reload register.  I.e.
845      technically this is a non-optional input-output reload, but IN is
846      already a valid register, and has been chosen as the reload register.
847      Speed this up, since it trivially works.  */
848   if (REG_P (in))
849     return 1;
850
851   /* To test MEMs properly, we'd have to take into account all the reloads
852      that are already scheduled, which can become quite complicated.
853      And since we've already handled address reloads for this MEM, it
854      should always succeed anyway.  */
855   if (MEM_P (in))
856     return 1;
857
858   /* If we can make a simple SET insn that does the job, everything should
859      be fine.  */
860   dst =  gen_rtx_REG (mode, regno);
861   test_insn = make_insn_raw (gen_rtx_SET (VOIDmode, dst, in));
862   save_recog_data = recog_data;
863   if (recog_memoized (test_insn) >= 0)
864     {
865       extract_insn (test_insn);
866       r = constrain_operands (1);
867     }
868   recog_data = save_recog_data;
869   return r;
870 }
871
872 /* Record one reload that needs to be performed.
873    IN is an rtx saying where the data are to be found before this instruction.
874    OUT says where they must be stored after the instruction.
875    (IN is zero for data not read, and OUT is zero for data not written.)
876    INLOC and OUTLOC point to the places in the instructions where
877    IN and OUT were found.
878    If IN and OUT are both nonzero, it means the same register must be used
879    to reload both IN and OUT.
880
881    RCLASS is a register class required for the reloaded data.
882    INMODE is the machine mode that the instruction requires
883    for the reg that replaces IN and OUTMODE is likewise for OUT.
884
885    If IN is zero, then OUT's location and mode should be passed as
886    INLOC and INMODE.
887
888    STRICT_LOW is the 1 if there is a containing STRICT_LOW_PART rtx.
889
890    OPTIONAL nonzero means this reload does not need to be performed:
891    it can be discarded if that is more convenient.
892
893    OPNUM and TYPE say what the purpose of this reload is.
894
895    The return value is the reload-number for this reload.
896
897    If both IN and OUT are nonzero, in some rare cases we might
898    want to make two separate reloads.  (Actually we never do this now.)
899    Therefore, the reload-number for OUT is stored in
900    output_reloadnum when we return; the return value applies to IN.
901    Usually (presently always), when IN and OUT are nonzero,
902    the two reload-numbers are equal, but the caller should be careful to
903    distinguish them.  */
904
905 int
906 push_reload (rtx in, rtx out, rtx *inloc, rtx *outloc,
907              enum reg_class rclass, enum machine_mode inmode,
908              enum machine_mode outmode, int strict_low, int optional,
909              int opnum, enum reload_type type)
910 {
911   int i;
912   int dont_share = 0;
913   int dont_remove_subreg = 0;
914   rtx *in_subreg_loc = 0, *out_subreg_loc = 0;
915   int secondary_in_reload = -1, secondary_out_reload = -1;
916   enum insn_code secondary_in_icode = CODE_FOR_nothing;
917   enum insn_code secondary_out_icode = CODE_FOR_nothing;
918
919   /* INMODE and/or OUTMODE could be VOIDmode if no mode
920      has been specified for the operand.  In that case,
921      use the operand's mode as the mode to reload.  */
922   if (inmode == VOIDmode && in != 0)
923     inmode = GET_MODE (in);
924   if (outmode == VOIDmode && out != 0)
925     outmode = GET_MODE (out);
926
927   /* If find_reloads and friends until now missed to replace a pseudo
928      with a constant of reg_equiv_constant something went wrong
929      beforehand.
930      Note that it can't simply be done here if we missed it earlier
931      since the constant might need to be pushed into the literal pool
932      and the resulting memref would probably need further
933      reloading.  */
934   if (in != 0 && REG_P (in))
935     {
936       int regno = REGNO (in);
937
938       gcc_assert (regno < FIRST_PSEUDO_REGISTER
939                   || reg_renumber[regno] >= 0
940                   || reg_equiv_constant[regno] == NULL_RTX);
941     }
942
943   /* reg_equiv_constant only contains constants which are obviously
944      not appropriate as destination.  So if we would need to replace
945      the destination pseudo with a constant we are in real
946      trouble.  */
947   if (out != 0 && REG_P (out))
948     {
949       int regno = REGNO (out);
950
951       gcc_assert (regno < FIRST_PSEUDO_REGISTER
952                   || reg_renumber[regno] >= 0
953                   || reg_equiv_constant[regno] == NULL_RTX);
954     }
955
956   /* If we have a read-write operand with an address side-effect,
957      change either IN or OUT so the side-effect happens only once.  */
958   if (in != 0 && out != 0 && MEM_P (in) && rtx_equal_p (in, out))
959     switch (GET_CODE (XEXP (in, 0)))
960       {
961       case POST_INC: case POST_DEC:   case POST_MODIFY:
962         in = replace_equiv_address_nv (in, XEXP (XEXP (in, 0), 0));
963         break;
964
965       case PRE_INC: case PRE_DEC: case PRE_MODIFY:
966         out = replace_equiv_address_nv (out, XEXP (XEXP (out, 0), 0));
967         break;
968
969       default:
970         break;
971       }
972
973   /* If we are reloading a (SUBREG constant ...), really reload just the
974      inside expression in its own mode.  Similarly for (SUBREG (PLUS ...)).
975      If we have (SUBREG:M1 (MEM:M2 ...) ...) (or an inner REG that is still
976      a pseudo and hence will become a MEM) with M1 wider than M2 and the
977      register is a pseudo, also reload the inside expression.
978      For machines that extend byte loads, do this for any SUBREG of a pseudo
979      where both M1 and M2 are a word or smaller, M1 is wider than M2, and
980      M2 is an integral mode that gets extended when loaded.
981      Similar issue for (SUBREG:M1 (REG:M2 ...) ...) for a hard register R where
982      either M1 is not valid for R or M2 is wider than a word but we only
983      need one word to store an M2-sized quantity in R.
984      (However, if OUT is nonzero, we need to reload the reg *and*
985      the subreg, so do nothing here, and let following statement handle it.)
986
987      Note that the case of (SUBREG (CONST_INT...)...) is handled elsewhere;
988      we can't handle it here because CONST_INT does not indicate a mode.
989
990      Similarly, we must reload the inside expression if we have a
991      STRICT_LOW_PART (presumably, in == out in this case).
992
993      Also reload the inner expression if it does not require a secondary
994      reload but the SUBREG does.
995
996      Finally, reload the inner expression if it is a register that is in
997      the class whose registers cannot be referenced in a different size
998      and M1 is not the same size as M2.  If subreg_lowpart_p is false, we
999      cannot reload just the inside since we might end up with the wrong
1000      register class.  But if it is inside a STRICT_LOW_PART, we have
1001      no choice, so we hope we do get the right register class there.  */
1002
1003   if (in != 0 && GET_CODE (in) == SUBREG
1004       && (subreg_lowpart_p (in) || strict_low)
1005 #ifdef CANNOT_CHANGE_MODE_CLASS
1006       && !CANNOT_CHANGE_MODE_CLASS (GET_MODE (SUBREG_REG (in)), inmode, rclass)
1007 #endif
1008       && (CONSTANT_P (SUBREG_REG (in))
1009           || GET_CODE (SUBREG_REG (in)) == PLUS
1010           || strict_low
1011           || (((REG_P (SUBREG_REG (in))
1012                 && REGNO (SUBREG_REG (in)) >= FIRST_PSEUDO_REGISTER)
1013                || MEM_P (SUBREG_REG (in)))
1014               && ((GET_MODE_SIZE (inmode)
1015                    > GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))))
1016 #ifdef LOAD_EXTEND_OP
1017                   || (GET_MODE_SIZE (inmode) <= UNITS_PER_WORD
1018                       && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
1019                           <= UNITS_PER_WORD)
1020                       && (GET_MODE_SIZE (inmode)
1021                           > GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))))
1022                       && INTEGRAL_MODE_P (GET_MODE (SUBREG_REG (in)))
1023                       && LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (in))) != UNKNOWN)
1024 #endif
1025 #ifdef WORD_REGISTER_OPERATIONS
1026                   || ((GET_MODE_SIZE (inmode)
1027                        < GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))))
1028                       && ((GET_MODE_SIZE (inmode) - 1) / UNITS_PER_WORD ==
1029                           ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))) - 1)
1030                            / UNITS_PER_WORD)))
1031 #endif
1032                   ))
1033           || (REG_P (SUBREG_REG (in))
1034               && REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER
1035               /* The case where out is nonzero
1036                  is handled differently in the following statement.  */
1037               && (out == 0 || subreg_lowpart_p (in))
1038               && ((GET_MODE_SIZE (inmode) <= UNITS_PER_WORD
1039                    && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
1040                        > UNITS_PER_WORD)
1041                    && ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
1042                         / UNITS_PER_WORD)
1043                        != (int) hard_regno_nregs[REGNO (SUBREG_REG (in))]
1044                                                 [GET_MODE (SUBREG_REG (in))]))
1045                   || ! HARD_REGNO_MODE_OK (subreg_regno (in), inmode)))
1046           || (secondary_reload_class (1, rclass, inmode, in) != NO_REGS
1047               && (secondary_reload_class (1, rclass, GET_MODE (SUBREG_REG (in)),
1048                                           SUBREG_REG (in))
1049                   == NO_REGS))
1050 #ifdef CANNOT_CHANGE_MODE_CLASS
1051           || (REG_P (SUBREG_REG (in))
1052               && REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER
1053               && REG_CANNOT_CHANGE_MODE_P
1054               (REGNO (SUBREG_REG (in)), GET_MODE (SUBREG_REG (in)), inmode))
1055 #endif
1056           ))
1057     {
1058       in_subreg_loc = inloc;
1059       inloc = &SUBREG_REG (in);
1060       in = *inloc;
1061 #if ! defined (LOAD_EXTEND_OP) && ! defined (WORD_REGISTER_OPERATIONS)
1062       if (MEM_P (in))
1063         /* This is supposed to happen only for paradoxical subregs made by
1064            combine.c.  (SUBREG (MEM)) isn't supposed to occur other ways.  */
1065         gcc_assert (GET_MODE_SIZE (GET_MODE (in)) <= GET_MODE_SIZE (inmode));
1066 #endif
1067       inmode = GET_MODE (in);
1068     }
1069
1070   /* Similar issue for (SUBREG:M1 (REG:M2 ...) ...) for a hard register R where
1071      either M1 is not valid for R or M2 is wider than a word but we only
1072      need one word to store an M2-sized quantity in R.
1073
1074      However, we must reload the inner reg *as well as* the subreg in
1075      that case.  */
1076
1077   /* Similar issue for (SUBREG constant ...) if it was not handled by the
1078      code above.  This can happen if SUBREG_BYTE != 0.  */
1079
1080   if (in != 0 && reload_inner_reg_of_subreg (in, inmode, 0))
1081     {
1082       enum reg_class in_class = rclass;
1083
1084       if (REG_P (SUBREG_REG (in)))
1085         in_class
1086           = find_valid_class (inmode, GET_MODE (SUBREG_REG (in)),
1087                               subreg_regno_offset (REGNO (SUBREG_REG (in)),
1088                                                    GET_MODE (SUBREG_REG (in)),
1089                                                    SUBREG_BYTE (in),
1090                                                    GET_MODE (in)),
1091                               REGNO (SUBREG_REG (in)));
1092
1093       /* This relies on the fact that emit_reload_insns outputs the
1094          instructions for input reloads of type RELOAD_OTHER in the same
1095          order as the reloads.  Thus if the outer reload is also of type
1096          RELOAD_OTHER, we are guaranteed that this inner reload will be
1097          output before the outer reload.  */
1098       push_reload (SUBREG_REG (in), NULL_RTX, &SUBREG_REG (in), (rtx *) 0,
1099                    in_class, VOIDmode, VOIDmode, 0, 0, opnum, type);
1100       dont_remove_subreg = 1;
1101     }
1102
1103   /* Similarly for paradoxical and problematical SUBREGs on the output.
1104      Note that there is no reason we need worry about the previous value
1105      of SUBREG_REG (out); even if wider than out,
1106      storing in a subreg is entitled to clobber it all
1107      (except in the case of STRICT_LOW_PART,
1108      and in that case the constraint should label it input-output.)  */
1109   if (out != 0 && GET_CODE (out) == SUBREG
1110       && (subreg_lowpart_p (out) || strict_low)
1111 #ifdef CANNOT_CHANGE_MODE_CLASS
1112       && !CANNOT_CHANGE_MODE_CLASS (GET_MODE (SUBREG_REG (out)), outmode, rclass)
1113 #endif
1114       && (CONSTANT_P (SUBREG_REG (out))
1115           || strict_low
1116           || (((REG_P (SUBREG_REG (out))
1117                 && REGNO (SUBREG_REG (out)) >= FIRST_PSEUDO_REGISTER)
1118                || MEM_P (SUBREG_REG (out)))
1119               && ((GET_MODE_SIZE (outmode)
1120                    > GET_MODE_SIZE (GET_MODE (SUBREG_REG (out))))
1121 #ifdef WORD_REGISTER_OPERATIONS
1122                   || ((GET_MODE_SIZE (outmode)
1123                        < GET_MODE_SIZE (GET_MODE (SUBREG_REG (out))))
1124                       && ((GET_MODE_SIZE (outmode) - 1) / UNITS_PER_WORD ==
1125                           ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (out))) - 1)
1126                            / UNITS_PER_WORD)))
1127 #endif
1128                   ))
1129           || (REG_P (SUBREG_REG (out))
1130               && REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER
1131               && ((GET_MODE_SIZE (outmode) <= UNITS_PER_WORD
1132                    && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (out)))
1133                        > UNITS_PER_WORD)
1134                    && ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (out)))
1135                         / UNITS_PER_WORD)
1136                        != (int) hard_regno_nregs[REGNO (SUBREG_REG (out))]
1137                                                 [GET_MODE (SUBREG_REG (out))]))
1138                   || ! HARD_REGNO_MODE_OK (subreg_regno (out), outmode)))
1139           || (secondary_reload_class (0, rclass, outmode, out) != NO_REGS
1140               && (secondary_reload_class (0, rclass, GET_MODE (SUBREG_REG (out)),
1141                                           SUBREG_REG (out))
1142                   == NO_REGS))
1143 #ifdef CANNOT_CHANGE_MODE_CLASS
1144           || (REG_P (SUBREG_REG (out))
1145               && REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER
1146               && REG_CANNOT_CHANGE_MODE_P (REGNO (SUBREG_REG (out)),
1147                                            GET_MODE (SUBREG_REG (out)),
1148                                            outmode))
1149 #endif
1150           ))
1151     {
1152       out_subreg_loc = outloc;
1153       outloc = &SUBREG_REG (out);
1154       out = *outloc;
1155 #if ! defined (LOAD_EXTEND_OP) && ! defined (WORD_REGISTER_OPERATIONS)
1156       gcc_assert (!MEM_P (out)
1157                   || GET_MODE_SIZE (GET_MODE (out))
1158                      <= GET_MODE_SIZE (outmode));
1159 #endif
1160       outmode = GET_MODE (out);
1161     }
1162
1163   /* Similar issue for (SUBREG:M1 (REG:M2 ...) ...) for a hard register R where
1164      either M1 is not valid for R or M2 is wider than a word but we only
1165      need one word to store an M2-sized quantity in R.
1166
1167      However, we must reload the inner reg *as well as* the subreg in
1168      that case.  In this case, the inner reg is an in-out reload.  */
1169
1170   if (out != 0 && reload_inner_reg_of_subreg (out, outmode, 1))
1171     {
1172       /* This relies on the fact that emit_reload_insns outputs the
1173          instructions for output reloads of type RELOAD_OTHER in reverse
1174          order of the reloads.  Thus if the outer reload is also of type
1175          RELOAD_OTHER, we are guaranteed that this inner reload will be
1176          output after the outer reload.  */
1177       dont_remove_subreg = 1;
1178       push_reload (SUBREG_REG (out), SUBREG_REG (out), &SUBREG_REG (out),
1179                    &SUBREG_REG (out),
1180                    find_valid_class (outmode, GET_MODE (SUBREG_REG (out)),
1181                                      subreg_regno_offset (REGNO (SUBREG_REG (out)),
1182                                                           GET_MODE (SUBREG_REG (out)),
1183                                                           SUBREG_BYTE (out),
1184                                                           GET_MODE (out)),
1185                                      REGNO (SUBREG_REG (out))),
1186                    VOIDmode, VOIDmode, 0, 0,
1187                    opnum, RELOAD_OTHER);
1188     }
1189
1190   /* If IN appears in OUT, we can't share any input-only reload for IN.  */
1191   if (in != 0 && out != 0 && MEM_P (out)
1192       && (REG_P (in) || MEM_P (in) || GET_CODE (in) == PLUS)
1193       && reg_overlap_mentioned_for_reload_p (in, XEXP (out, 0)))
1194     dont_share = 1;
1195
1196   /* If IN is a SUBREG of a hard register, make a new REG.  This
1197      simplifies some of the cases below.  */
1198
1199   if (in != 0 && GET_CODE (in) == SUBREG && REG_P (SUBREG_REG (in))
1200       && REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER
1201       && ! dont_remove_subreg)
1202     in = gen_rtx_REG (GET_MODE (in), subreg_regno (in));
1203
1204   /* Similarly for OUT.  */
1205   if (out != 0 && GET_CODE (out) == SUBREG
1206       && REG_P (SUBREG_REG (out))
1207       && REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER
1208       && ! dont_remove_subreg)
1209     out = gen_rtx_REG (GET_MODE (out), subreg_regno (out));
1210
1211   /* Narrow down the class of register wanted if that is
1212      desirable on this machine for efficiency.  */
1213   {
1214     enum reg_class preferred_class = rclass;
1215
1216     if (in != 0)
1217       preferred_class = PREFERRED_RELOAD_CLASS (in, rclass);
1218
1219   /* Output reloads may need analogous treatment, different in detail.  */
1220 #ifdef PREFERRED_OUTPUT_RELOAD_CLASS
1221     if (out != 0)
1222       preferred_class = PREFERRED_OUTPUT_RELOAD_CLASS (out, preferred_class);
1223 #endif
1224
1225     /* Discard what the target said if we cannot do it.  */
1226     if (preferred_class != NO_REGS
1227         || (optional && type == RELOAD_FOR_OUTPUT))
1228       rclass = preferred_class;
1229   }
1230
1231   /* Make sure we use a class that can handle the actual pseudo
1232      inside any subreg.  For example, on the 386, QImode regs
1233      can appear within SImode subregs.  Although GENERAL_REGS
1234      can handle SImode, QImode needs a smaller class.  */
1235 #ifdef LIMIT_RELOAD_CLASS
1236   if (in_subreg_loc)
1237     rclass = LIMIT_RELOAD_CLASS (inmode, rclass);
1238   else if (in != 0 && GET_CODE (in) == SUBREG)
1239     rclass = LIMIT_RELOAD_CLASS (GET_MODE (SUBREG_REG (in)), rclass);
1240
1241   if (out_subreg_loc)
1242     rclass = LIMIT_RELOAD_CLASS (outmode, rclass);
1243   if (out != 0 && GET_CODE (out) == SUBREG)
1244     rclass = LIMIT_RELOAD_CLASS (GET_MODE (SUBREG_REG (out)), rclass);
1245 #endif
1246
1247   /* Verify that this class is at least possible for the mode that
1248      is specified.  */
1249   if (this_insn_is_asm)
1250     {
1251       enum machine_mode mode;
1252       if (GET_MODE_SIZE (inmode) > GET_MODE_SIZE (outmode))
1253         mode = inmode;
1254       else
1255         mode = outmode;
1256       if (mode == VOIDmode)
1257         {
1258           error_for_asm (this_insn, "cannot reload integer constant "
1259                          "operand in %<asm%>");
1260           mode = word_mode;
1261           if (in != 0)
1262             inmode = word_mode;
1263           if (out != 0)
1264             outmode = word_mode;
1265         }
1266       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1267         if (HARD_REGNO_MODE_OK (i, mode)
1268             && in_hard_reg_set_p (reg_class_contents[(int) rclass], mode, i))
1269           break;
1270       if (i == FIRST_PSEUDO_REGISTER)
1271         {
1272           error_for_asm (this_insn, "impossible register constraint "
1273                          "in %<asm%>");
1274           /* Avoid further trouble with this insn.  */
1275           PATTERN (this_insn) = gen_rtx_USE (VOIDmode, const0_rtx);
1276           /* We used to continue here setting class to ALL_REGS, but it triggers
1277              sanity check on i386 for:
1278              void foo(long double d)
1279              {
1280                asm("" :: "a" (d));
1281              }
1282              Returning zero here ought to be safe as we take care in
1283              find_reloads to not process the reloads when instruction was
1284              replaced by USE.  */
1285             
1286           return 0;
1287         }
1288     }
1289
1290   /* Optional output reloads are always OK even if we have no register class,
1291      since the function of these reloads is only to have spill_reg_store etc.
1292      set, so that the storing insn can be deleted later.  */
1293   gcc_assert (rclass != NO_REGS
1294               || (optional != 0 && type == RELOAD_FOR_OUTPUT));
1295
1296   i = find_reusable_reload (&in, out, rclass, type, opnum, dont_share);
1297
1298   if (i == n_reloads)
1299     {
1300       /* See if we need a secondary reload register to move between CLASS
1301          and IN or CLASS and OUT.  Get the icode and push any required reloads
1302          needed for each of them if so.  */
1303
1304       if (in != 0)
1305         secondary_in_reload
1306           = push_secondary_reload (1, in, opnum, optional, rclass, inmode, type,
1307                                    &secondary_in_icode, NULL);
1308       if (out != 0 && GET_CODE (out) != SCRATCH)
1309         secondary_out_reload
1310           = push_secondary_reload (0, out, opnum, optional, rclass, outmode,
1311                                    type, &secondary_out_icode, NULL);
1312
1313       /* We found no existing reload suitable for re-use.
1314          So add an additional reload.  */
1315
1316 #ifdef SECONDARY_MEMORY_NEEDED
1317       /* If a memory location is needed for the copy, make one.  */
1318       if (in != 0
1319           && (REG_P (in)
1320               || (GET_CODE (in) == SUBREG && REG_P (SUBREG_REG (in))))
1321           && reg_or_subregno (in) < FIRST_PSEUDO_REGISTER
1322           && SECONDARY_MEMORY_NEEDED (REGNO_REG_CLASS (reg_or_subregno (in)),
1323                                       rclass, inmode))
1324         get_secondary_mem (in, inmode, opnum, type);
1325 #endif
1326
1327       i = n_reloads;
1328       rld[i].in = in;
1329       rld[i].out = out;
1330       rld[i].rclass = rclass;
1331       rld[i].inmode = inmode;
1332       rld[i].outmode = outmode;
1333       rld[i].reg_rtx = 0;
1334       rld[i].optional = optional;
1335       rld[i].inc = 0;
1336       rld[i].nocombine = 0;
1337       rld[i].in_reg = inloc ? *inloc : 0;
1338       rld[i].out_reg = outloc ? *outloc : 0;
1339       rld[i].opnum = opnum;
1340       rld[i].when_needed = type;
1341       rld[i].secondary_in_reload = secondary_in_reload;
1342       rld[i].secondary_out_reload = secondary_out_reload;
1343       rld[i].secondary_in_icode = secondary_in_icode;
1344       rld[i].secondary_out_icode = secondary_out_icode;
1345       rld[i].secondary_p = 0;
1346
1347       n_reloads++;
1348
1349 #ifdef SECONDARY_MEMORY_NEEDED
1350       if (out != 0
1351           && (REG_P (out)
1352               || (GET_CODE (out) == SUBREG && REG_P (SUBREG_REG (out))))
1353           && reg_or_subregno (out) < FIRST_PSEUDO_REGISTER
1354           && SECONDARY_MEMORY_NEEDED (rclass,
1355                                       REGNO_REG_CLASS (reg_or_subregno (out)),
1356                                       outmode))
1357         get_secondary_mem (out, outmode, opnum, type);
1358 #endif
1359     }
1360   else
1361     {
1362       /* We are reusing an existing reload,
1363          but we may have additional information for it.
1364          For example, we may now have both IN and OUT
1365          while the old one may have just one of them.  */
1366
1367       /* The modes can be different.  If they are, we want to reload in
1368          the larger mode, so that the value is valid for both modes.  */
1369       if (inmode != VOIDmode
1370           && GET_MODE_SIZE (inmode) > GET_MODE_SIZE (rld[i].inmode))
1371         rld[i].inmode = inmode;
1372       if (outmode != VOIDmode
1373           && GET_MODE_SIZE (outmode) > GET_MODE_SIZE (rld[i].outmode))
1374         rld[i].outmode = outmode;
1375       if (in != 0)
1376         {
1377           rtx in_reg = inloc ? *inloc : 0;
1378           /* If we merge reloads for two distinct rtl expressions that
1379              are identical in content, there might be duplicate address
1380              reloads.  Remove the extra set now, so that if we later find
1381              that we can inherit this reload, we can get rid of the
1382              address reloads altogether.
1383
1384              Do not do this if both reloads are optional since the result
1385              would be an optional reload which could potentially leave
1386              unresolved address replacements.
1387
1388              It is not sufficient to call transfer_replacements since
1389              choose_reload_regs will remove the replacements for address
1390              reloads of inherited reloads which results in the same
1391              problem.  */
1392           if (rld[i].in != in && rtx_equal_p (in, rld[i].in)
1393               && ! (rld[i].optional && optional))
1394             {
1395               /* We must keep the address reload with the lower operand
1396                  number alive.  */
1397               if (opnum > rld[i].opnum)
1398                 {
1399                   remove_address_replacements (in);
1400                   in = rld[i].in;
1401                   in_reg = rld[i].in_reg;
1402                 }
1403               else
1404                 remove_address_replacements (rld[i].in);
1405             }
1406           /* When emitting reloads we don't necessarily look at the in-
1407              and outmode, but also directly at the operands (in and out).
1408              So we can't simply overwrite them with whatever we have found
1409              for this (to-be-merged) reload, we have to "merge" that too.
1410              Reusing another reload already verified that we deal with the
1411              same operands, just possibly in different modes.  So we
1412              overwrite the operands only when the new mode is larger.
1413              See also PR33613.  */
1414           if (!rld[i].in
1415               || GET_MODE_SIZE (GET_MODE (in))
1416                    > GET_MODE_SIZE (GET_MODE (rld[i].in)))
1417             rld[i].in = in;
1418           if (!rld[i].in_reg
1419               || (in_reg
1420                   && GET_MODE_SIZE (GET_MODE (in_reg))
1421                      > GET_MODE_SIZE (GET_MODE (rld[i].in_reg))))
1422             rld[i].in_reg = in_reg;
1423         }
1424       if (out != 0)
1425         {
1426           if (!rld[i].out
1427               || (out
1428                   && GET_MODE_SIZE (GET_MODE (out))
1429                      > GET_MODE_SIZE (GET_MODE (rld[i].out))))
1430             rld[i].out = out;
1431           if (outloc
1432               && (!rld[i].out_reg
1433                   || GET_MODE_SIZE (GET_MODE (*outloc))
1434                      > GET_MODE_SIZE (GET_MODE (rld[i].out_reg))))
1435             rld[i].out_reg = *outloc;
1436         }
1437       if (reg_class_subset_p (rclass, rld[i].rclass))
1438         rld[i].rclass = rclass;
1439       rld[i].optional &= optional;
1440       if (MERGE_TO_OTHER (type, rld[i].when_needed,
1441                           opnum, rld[i].opnum))
1442         rld[i].when_needed = RELOAD_OTHER;
1443       rld[i].opnum = MIN (rld[i].opnum, opnum);
1444     }
1445
1446   /* If the ostensible rtx being reloaded differs from the rtx found
1447      in the location to substitute, this reload is not safe to combine
1448      because we cannot reliably tell whether it appears in the insn.  */
1449
1450   if (in != 0 && in != *inloc)
1451     rld[i].nocombine = 1;
1452
1453 #if 0
1454   /* This was replaced by changes in find_reloads_address_1 and the new
1455      function inc_for_reload, which go with a new meaning of reload_inc.  */
1456
1457   /* If this is an IN/OUT reload in an insn that sets the CC,
1458      it must be for an autoincrement.  It doesn't work to store
1459      the incremented value after the insn because that would clobber the CC.
1460      So we must do the increment of the value reloaded from,
1461      increment it, store it back, then decrement again.  */
1462   if (out != 0 && sets_cc0_p (PATTERN (this_insn)))
1463     {
1464       out = 0;
1465       rld[i].out = 0;
1466       rld[i].inc = find_inc_amount (PATTERN (this_insn), in);
1467       /* If we did not find a nonzero amount-to-increment-by,
1468          that contradicts the belief that IN is being incremented
1469          in an address in this insn.  */
1470       gcc_assert (rld[i].inc != 0);
1471     }
1472 #endif
1473
1474   /* If we will replace IN and OUT with the reload-reg,
1475      record where they are located so that substitution need
1476      not do a tree walk.  */
1477
1478   if (replace_reloads)
1479     {
1480       if (inloc != 0)
1481         {
1482           struct replacement *r = &replacements[n_replacements++];
1483           r->what = i;
1484           r->subreg_loc = in_subreg_loc;
1485           r->where = inloc;
1486           r->mode = inmode;
1487         }
1488       if (outloc != 0 && outloc != inloc)
1489         {
1490           struct replacement *r = &replacements[n_replacements++];
1491           r->what = i;
1492           r->where = outloc;
1493           r->subreg_loc = out_subreg_loc;
1494           r->mode = outmode;
1495         }
1496     }
1497
1498   /* If this reload is just being introduced and it has both
1499      an incoming quantity and an outgoing quantity that are
1500      supposed to be made to match, see if either one of the two
1501      can serve as the place to reload into.
1502
1503      If one of them is acceptable, set rld[i].reg_rtx
1504      to that one.  */
1505
1506   if (in != 0 && out != 0 && in != out && rld[i].reg_rtx == 0)
1507     {
1508       rld[i].reg_rtx = find_dummy_reload (in, out, inloc, outloc,
1509                                           inmode, outmode,
1510                                           rld[i].rclass, i,
1511                                           earlyclobber_operand_p (out));
1512
1513       /* If the outgoing register already contains the same value
1514          as the incoming one, we can dispense with loading it.
1515          The easiest way to tell the caller that is to give a phony
1516          value for the incoming operand (same as outgoing one).  */
1517       if (rld[i].reg_rtx == out
1518           && (REG_P (in) || CONSTANT_P (in))
1519           && 0 != find_equiv_reg (in, this_insn, 0, REGNO (out),
1520                                   static_reload_reg_p, i, inmode))
1521         rld[i].in = out;
1522     }
1523
1524   /* If this is an input reload and the operand contains a register that
1525      dies in this insn and is used nowhere else, see if it is the right class
1526      to be used for this reload.  Use it if so.  (This occurs most commonly
1527      in the case of paradoxical SUBREGs and in-out reloads).  We cannot do
1528      this if it is also an output reload that mentions the register unless
1529      the output is a SUBREG that clobbers an entire register.
1530
1531      Note that the operand might be one of the spill regs, if it is a
1532      pseudo reg and we are in a block where spilling has not taken place.
1533      But if there is no spilling in this block, that is OK.
1534      An explicitly used hard reg cannot be a spill reg.  */
1535
1536   if (rld[i].reg_rtx == 0 && in != 0 && hard_regs_live_known)
1537     {
1538       rtx note;
1539       int regno;
1540       enum machine_mode rel_mode = inmode;
1541
1542       if (out && GET_MODE_SIZE (outmode) > GET_MODE_SIZE (inmode))
1543         rel_mode = outmode;
1544
1545       for (note = REG_NOTES (this_insn); note; note = XEXP (note, 1))
1546         if (REG_NOTE_KIND (note) == REG_DEAD
1547             && REG_P (XEXP (note, 0))
1548             && (regno = REGNO (XEXP (note, 0))) < FIRST_PSEUDO_REGISTER
1549             && reg_mentioned_p (XEXP (note, 0), in)
1550             /* Check that a former pseudo is valid; see find_dummy_reload.  */
1551             && (ORIGINAL_REGNO (XEXP (note, 0)) < FIRST_PSEUDO_REGISTER
1552                 || (! bitmap_bit_p (DF_LR_OUT (ENTRY_BLOCK_PTR),
1553                                     ORIGINAL_REGNO (XEXP (note, 0)))
1554                     && hard_regno_nregs[regno][GET_MODE (XEXP (note, 0))] == 1))
1555             && ! refers_to_regno_for_reload_p (regno,
1556                                                end_hard_regno (rel_mode,
1557                                                                regno),
1558                                                PATTERN (this_insn), inloc)
1559             /* If this is also an output reload, IN cannot be used as
1560                the reload register if it is set in this insn unless IN
1561                is also OUT.  */
1562             && (out == 0 || in == out
1563                 || ! hard_reg_set_here_p (regno,
1564                                           end_hard_regno (rel_mode, regno),
1565                                           PATTERN (this_insn)))
1566             /* ??? Why is this code so different from the previous?
1567                Is there any simple coherent way to describe the two together?
1568                What's going on here.  */
1569             && (in != out
1570                 || (GET_CODE (in) == SUBREG
1571                     && (((GET_MODE_SIZE (GET_MODE (in)) + (UNITS_PER_WORD - 1))
1572                          / UNITS_PER_WORD)
1573                         == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
1574                              + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD))))
1575             /* Make sure the operand fits in the reg that dies.  */
1576             && (GET_MODE_SIZE (rel_mode)
1577                 <= GET_MODE_SIZE (GET_MODE (XEXP (note, 0))))
1578             && HARD_REGNO_MODE_OK (regno, inmode)
1579             && HARD_REGNO_MODE_OK (regno, outmode))
1580           {
1581             unsigned int offs;
1582             unsigned int nregs = MAX (hard_regno_nregs[regno][inmode],
1583                                       hard_regno_nregs[regno][outmode]);
1584
1585             for (offs = 0; offs < nregs; offs++)
1586               if (fixed_regs[regno + offs]
1587                   || ! TEST_HARD_REG_BIT (reg_class_contents[(int) rclass],
1588                                           regno + offs))
1589                 break;
1590
1591             if (offs == nregs
1592                 && (! (refers_to_regno_for_reload_p
1593                        (regno, end_hard_regno (inmode, regno), in, (rtx *) 0))
1594                     || can_reload_into (in, regno, inmode)))
1595               {
1596                 rld[i].reg_rtx = gen_rtx_REG (rel_mode, regno);
1597                 break;
1598               }
1599           }
1600     }
1601
1602   if (out)
1603     output_reloadnum = i;
1604
1605   return i;
1606 }
1607
1608 /* Record an additional place we must replace a value
1609    for which we have already recorded a reload.
1610    RELOADNUM is the value returned by push_reload
1611    when the reload was recorded.
1612    This is used in insn patterns that use match_dup.  */
1613
1614 static void
1615 push_replacement (rtx *loc, int reloadnum, enum machine_mode mode)
1616 {
1617   if (replace_reloads)
1618     {
1619       struct replacement *r = &replacements[n_replacements++];
1620       r->what = reloadnum;
1621       r->where = loc;
1622       r->subreg_loc = 0;
1623       r->mode = mode;
1624     }
1625 }
1626
1627 /* Duplicate any replacement we have recorded to apply at
1628    location ORIG_LOC to also be performed at DUP_LOC.
1629    This is used in insn patterns that use match_dup.  */
1630
1631 static void
1632 dup_replacements (rtx *dup_loc, rtx *orig_loc)
1633 {
1634   int i, n = n_replacements;
1635
1636   for (i = 0; i < n; i++)
1637     {
1638       struct replacement *r = &replacements[i];
1639       if (r->where == orig_loc)
1640         push_replacement (dup_loc, r->what, r->mode);
1641     }
1642 }
1643 \f
1644 /* Transfer all replacements that used to be in reload FROM to be in
1645    reload TO.  */
1646
1647 void
1648 transfer_replacements (int to, int from)
1649 {
1650   int i;
1651
1652   for (i = 0; i < n_replacements; i++)
1653     if (replacements[i].what == from)
1654       replacements[i].what = to;
1655 }
1656 \f
1657 /* IN_RTX is the value loaded by a reload that we now decided to inherit,
1658    or a subpart of it.  If we have any replacements registered for IN_RTX,
1659    cancel the reloads that were supposed to load them.
1660    Return nonzero if we canceled any reloads.  */
1661 int
1662 remove_address_replacements (rtx in_rtx)
1663 {
1664   int i, j;
1665   char reload_flags[MAX_RELOADS];
1666   int something_changed = 0;
1667
1668   memset (reload_flags, 0, sizeof reload_flags);
1669   for (i = 0, j = 0; i < n_replacements; i++)
1670     {
1671       if (loc_mentioned_in_p (replacements[i].where, in_rtx))
1672         reload_flags[replacements[i].what] |= 1;
1673       else
1674         {
1675           replacements[j++] = replacements[i];
1676           reload_flags[replacements[i].what] |= 2;
1677         }
1678     }
1679   /* Note that the following store must be done before the recursive calls.  */
1680   n_replacements = j;
1681
1682   for (i = n_reloads - 1; i >= 0; i--)
1683     {
1684       if (reload_flags[i] == 1)
1685         {
1686           deallocate_reload_reg (i);
1687           remove_address_replacements (rld[i].in);
1688           rld[i].in = 0;
1689           something_changed = 1;
1690         }
1691     }
1692   return something_changed;
1693 }
1694 \f
1695 /* If there is only one output reload, and it is not for an earlyclobber
1696    operand, try to combine it with a (logically unrelated) input reload
1697    to reduce the number of reload registers needed.
1698
1699    This is safe if the input reload does not appear in
1700    the value being output-reloaded, because this implies
1701    it is not needed any more once the original insn completes.
1702
1703    If that doesn't work, see we can use any of the registers that
1704    die in this insn as a reload register.  We can if it is of the right
1705    class and does not appear in the value being output-reloaded.  */
1706
1707 static void
1708 combine_reloads (void)
1709 {
1710   int i, regno;
1711   int output_reload = -1;
1712   int secondary_out = -1;
1713   rtx note;
1714
1715   /* Find the output reload; return unless there is exactly one
1716      and that one is mandatory.  */
1717
1718   for (i = 0; i < n_reloads; i++)
1719     if (rld[i].out != 0)
1720       {
1721         if (output_reload >= 0)
1722           return;
1723         output_reload = i;
1724       }
1725
1726   if (output_reload < 0 || rld[output_reload].optional)
1727     return;
1728
1729   /* An input-output reload isn't combinable.  */
1730
1731   if (rld[output_reload].in != 0)
1732     return;
1733
1734   /* If this reload is for an earlyclobber operand, we can't do anything.  */
1735   if (earlyclobber_operand_p (rld[output_reload].out))
1736     return;
1737
1738   /* If there is a reload for part of the address of this operand, we would
1739      need to change it to RELOAD_FOR_OTHER_ADDRESS.  But that would extend
1740      its life to the point where doing this combine would not lower the
1741      number of spill registers needed.  */
1742   for (i = 0; i < n_reloads; i++)
1743     if ((rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS
1744          || rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
1745         && rld[i].opnum == rld[output_reload].opnum)
1746       return;
1747
1748   /* Check each input reload; can we combine it?  */
1749
1750   for (i = 0; i < n_reloads; i++)
1751     if (rld[i].in && ! rld[i].optional && ! rld[i].nocombine
1752         /* Life span of this reload must not extend past main insn.  */
1753         && rld[i].when_needed != RELOAD_FOR_OUTPUT_ADDRESS
1754         && rld[i].when_needed != RELOAD_FOR_OUTADDR_ADDRESS
1755         && rld[i].when_needed != RELOAD_OTHER
1756         && (CLASS_MAX_NREGS (rld[i].rclass, rld[i].inmode)
1757             == CLASS_MAX_NREGS (rld[output_reload].rclass,
1758                                 rld[output_reload].outmode))
1759         && rld[i].inc == 0
1760         && rld[i].reg_rtx == 0
1761 #ifdef SECONDARY_MEMORY_NEEDED
1762         /* Don't combine two reloads with different secondary
1763            memory locations.  */
1764         && (secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[i].opnum] == 0
1765             || secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[output_reload].opnum] == 0
1766             || rtx_equal_p (secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[i].opnum],
1767                             secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[output_reload].opnum]))
1768 #endif
1769         && (SMALL_REGISTER_CLASSES
1770             ? (rld[i].rclass == rld[output_reload].rclass)
1771             : (reg_class_subset_p (rld[i].rclass,
1772                                    rld[output_reload].rclass)
1773                || reg_class_subset_p (rld[output_reload].rclass,
1774                                       rld[i].rclass)))
1775         && (MATCHES (rld[i].in, rld[output_reload].out)
1776             /* Args reversed because the first arg seems to be
1777                the one that we imagine being modified
1778                while the second is the one that might be affected.  */
1779             || (! reg_overlap_mentioned_for_reload_p (rld[output_reload].out,
1780                                                       rld[i].in)
1781                 /* However, if the input is a register that appears inside
1782                    the output, then we also can't share.
1783                    Imagine (set (mem (reg 69)) (plus (reg 69) ...)).
1784                    If the same reload reg is used for both reg 69 and the
1785                    result to be stored in memory, then that result
1786                    will clobber the address of the memory ref.  */
1787                 && ! (REG_P (rld[i].in)
1788                       && reg_overlap_mentioned_for_reload_p (rld[i].in,
1789                                                              rld[output_reload].out))))
1790         && ! reload_inner_reg_of_subreg (rld[i].in, rld[i].inmode,
1791                                          rld[i].when_needed != RELOAD_FOR_INPUT)
1792         && (reg_class_size[(int) rld[i].rclass]
1793             || SMALL_REGISTER_CLASSES)
1794         /* We will allow making things slightly worse by combining an
1795            input and an output, but no worse than that.  */
1796         && (rld[i].when_needed == RELOAD_FOR_INPUT
1797             || rld[i].when_needed == RELOAD_FOR_OUTPUT))
1798       {
1799         int j;
1800
1801         /* We have found a reload to combine with!  */
1802         rld[i].out = rld[output_reload].out;
1803         rld[i].out_reg = rld[output_reload].out_reg;
1804         rld[i].outmode = rld[output_reload].outmode;
1805         /* Mark the old output reload as inoperative.  */
1806         rld[output_reload].out = 0;
1807         /* The combined reload is needed for the entire insn.  */
1808         rld[i].when_needed = RELOAD_OTHER;
1809         /* If the output reload had a secondary reload, copy it.  */
1810         if (rld[output_reload].secondary_out_reload != -1)
1811           {
1812             rld[i].secondary_out_reload
1813               = rld[output_reload].secondary_out_reload;
1814             rld[i].secondary_out_icode
1815               = rld[output_reload].secondary_out_icode;
1816           }
1817
1818 #ifdef SECONDARY_MEMORY_NEEDED
1819         /* Copy any secondary MEM.  */
1820         if (secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[output_reload].opnum] != 0)
1821           secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[i].opnum]
1822             = secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[output_reload].opnum];
1823 #endif
1824         /* If required, minimize the register class.  */
1825         if (reg_class_subset_p (rld[output_reload].rclass,
1826                                 rld[i].rclass))
1827           rld[i].rclass = rld[output_reload].rclass;
1828
1829         /* Transfer all replacements from the old reload to the combined.  */
1830         for (j = 0; j < n_replacements; j++)
1831           if (replacements[j].what == output_reload)
1832             replacements[j].what = i;
1833
1834         return;
1835       }
1836
1837   /* If this insn has only one operand that is modified or written (assumed
1838      to be the first),  it must be the one corresponding to this reload.  It
1839      is safe to use anything that dies in this insn for that output provided
1840      that it does not occur in the output (we already know it isn't an
1841      earlyclobber.  If this is an asm insn, give up.  */
1842
1843   if (INSN_CODE (this_insn) == -1)
1844     return;
1845
1846   for (i = 1; i < insn_data[INSN_CODE (this_insn)].n_operands; i++)
1847     if (insn_data[INSN_CODE (this_insn)].operand[i].constraint[0] == '='
1848         || insn_data[INSN_CODE (this_insn)].operand[i].constraint[0] == '+')
1849       return;
1850
1851   /* See if some hard register that dies in this insn and is not used in
1852      the output is the right class.  Only works if the register we pick
1853      up can fully hold our output reload.  */
1854   for (note = REG_NOTES (this_insn); note; note = XEXP (note, 1))
1855     if (REG_NOTE_KIND (note) == REG_DEAD
1856         && REG_P (XEXP (note, 0))
1857         && !reg_overlap_mentioned_for_reload_p (XEXP (note, 0),
1858                                                 rld[output_reload].out)
1859         && (regno = REGNO (XEXP (note, 0))) < FIRST_PSEUDO_REGISTER
1860         && HARD_REGNO_MODE_OK (regno, rld[output_reload].outmode)
1861         && TEST_HARD_REG_BIT (reg_class_contents[(int) rld[output_reload].rclass],
1862                               regno)
1863         && (hard_regno_nregs[regno][rld[output_reload].outmode]
1864             <= hard_regno_nregs[regno][GET_MODE (XEXP (note, 0))])
1865         /* Ensure that a secondary or tertiary reload for this output
1866            won't want this register.  */
1867         && ((secondary_out = rld[output_reload].secondary_out_reload) == -1
1868             || (!(TEST_HARD_REG_BIT
1869                   (reg_class_contents[(int) rld[secondary_out].rclass], regno))
1870                 && ((secondary_out = rld[secondary_out].secondary_out_reload) == -1
1871                     || !(TEST_HARD_REG_BIT
1872                          (reg_class_contents[(int) rld[secondary_out].rclass],
1873                           regno)))))
1874         && !fixed_regs[regno]
1875         /* Check that a former pseudo is valid; see find_dummy_reload.  */
1876         && (ORIGINAL_REGNO (XEXP (note, 0)) < FIRST_PSEUDO_REGISTER
1877             || (!bitmap_bit_p (DF_LR_OUT (ENTRY_BLOCK_PTR),
1878                                ORIGINAL_REGNO (XEXP (note, 0)))
1879                 && hard_regno_nregs[regno][GET_MODE (XEXP (note, 0))] == 1)))
1880       {
1881         rld[output_reload].reg_rtx
1882           = gen_rtx_REG (rld[output_reload].outmode, regno);
1883         return;
1884       }
1885 }
1886 \f
1887 /* Try to find a reload register for an in-out reload (expressions IN and OUT).
1888    See if one of IN and OUT is a register that may be used;
1889    this is desirable since a spill-register won't be needed.
1890    If so, return the register rtx that proves acceptable.
1891
1892    INLOC and OUTLOC are locations where IN and OUT appear in the insn.
1893    RCLASS is the register class required for the reload.
1894
1895    If FOR_REAL is >= 0, it is the number of the reload,
1896    and in some cases when it can be discovered that OUT doesn't need
1897    to be computed, clear out rld[FOR_REAL].out.
1898
1899    If FOR_REAL is -1, this should not be done, because this call
1900    is just to see if a register can be found, not to find and install it.
1901
1902    EARLYCLOBBER is nonzero if OUT is an earlyclobber operand.  This
1903    puts an additional constraint on being able to use IN for OUT since
1904    IN must not appear elsewhere in the insn (it is assumed that IN itself
1905    is safe from the earlyclobber).  */
1906
1907 static rtx
1908 find_dummy_reload (rtx real_in, rtx real_out, rtx *inloc, rtx *outloc,
1909                    enum machine_mode inmode, enum machine_mode outmode,
1910                    enum reg_class rclass, int for_real, int earlyclobber)
1911 {
1912   rtx in = real_in;
1913   rtx out = real_out;
1914   int in_offset = 0;
1915   int out_offset = 0;
1916   rtx value = 0;
1917
1918   /* If operands exceed a word, we can't use either of them
1919      unless they have the same size.  */
1920   if (GET_MODE_SIZE (outmode) != GET_MODE_SIZE (inmode)
1921       && (GET_MODE_SIZE (outmode) > UNITS_PER_WORD
1922           || GET_MODE_SIZE (inmode) > UNITS_PER_WORD))
1923     return 0;
1924
1925   /* Note that {in,out}_offset are needed only when 'in' or 'out'
1926      respectively refers to a hard register.  */
1927
1928   /* Find the inside of any subregs.  */
1929   while (GET_CODE (out) == SUBREG)
1930     {
1931       if (REG_P (SUBREG_REG (out))
1932           && REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER)
1933         out_offset += subreg_regno_offset (REGNO (SUBREG_REG (out)),
1934                                            GET_MODE (SUBREG_REG (out)),
1935                                            SUBREG_BYTE (out),
1936                                            GET_MODE (out));
1937       out = SUBREG_REG (out);
1938     }
1939   while (GET_CODE (in) == SUBREG)
1940     {
1941       if (REG_P (SUBREG_REG (in))
1942           && REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER)
1943         in_offset += subreg_regno_offset (REGNO (SUBREG_REG (in)),
1944                                           GET_MODE (SUBREG_REG (in)),
1945                                           SUBREG_BYTE (in),
1946                                           GET_MODE (in));
1947       in = SUBREG_REG (in);
1948     }
1949
1950   /* Narrow down the reg class, the same way push_reload will;
1951      otherwise we might find a dummy now, but push_reload won't.  */
1952   {
1953     enum reg_class preferred_class = PREFERRED_RELOAD_CLASS (in, rclass);
1954     if (preferred_class != NO_REGS)
1955       rclass = preferred_class;
1956   }
1957
1958   /* See if OUT will do.  */
1959   if (REG_P (out)
1960       && REGNO (out) < FIRST_PSEUDO_REGISTER)
1961     {
1962       unsigned int regno = REGNO (out) + out_offset;
1963       unsigned int nwords = hard_regno_nregs[regno][outmode];
1964       rtx saved_rtx;
1965
1966       /* When we consider whether the insn uses OUT,
1967          ignore references within IN.  They don't prevent us
1968          from copying IN into OUT, because those refs would
1969          move into the insn that reloads IN.
1970
1971          However, we only ignore IN in its role as this reload.
1972          If the insn uses IN elsewhere and it contains OUT,
1973          that counts.  We can't be sure it's the "same" operand
1974          so it might not go through this reload.  */
1975       saved_rtx = *inloc;
1976       *inloc = const0_rtx;
1977
1978       if (regno < FIRST_PSEUDO_REGISTER
1979           && HARD_REGNO_MODE_OK (regno, outmode)
1980           && ! refers_to_regno_for_reload_p (regno, regno + nwords,
1981                                              PATTERN (this_insn), outloc))
1982         {
1983           unsigned int i;
1984
1985           for (i = 0; i < nwords; i++)
1986             if (! TEST_HARD_REG_BIT (reg_class_contents[(int) rclass],
1987                                      regno + i))
1988               break;
1989
1990           if (i == nwords)
1991             {
1992               if (REG_P (real_out))
1993                 value = real_out;
1994               else
1995                 value = gen_rtx_REG (outmode, regno);
1996             }
1997         }
1998
1999       *inloc = saved_rtx;
2000     }
2001
2002   /* Consider using IN if OUT was not acceptable
2003      or if OUT dies in this insn (like the quotient in a divmod insn).
2004      We can't use IN unless it is dies in this insn,
2005      which means we must know accurately which hard regs are live.
2006      Also, the result can't go in IN if IN is used within OUT,
2007      or if OUT is an earlyclobber and IN appears elsewhere in the insn.  */
2008   if (hard_regs_live_known
2009       && REG_P (in)
2010       && REGNO (in) < FIRST_PSEUDO_REGISTER
2011       && (value == 0
2012           || find_reg_note (this_insn, REG_UNUSED, real_out))
2013       && find_reg_note (this_insn, REG_DEAD, real_in)
2014       && !fixed_regs[REGNO (in)]
2015       && HARD_REGNO_MODE_OK (REGNO (in),
2016                              /* The only case where out and real_out might
2017                                 have different modes is where real_out
2018                                 is a subreg, and in that case, out
2019                                 has a real mode.  */
2020                              (GET_MODE (out) != VOIDmode
2021                               ? GET_MODE (out) : outmode))
2022       && (ORIGINAL_REGNO (in) < FIRST_PSEUDO_REGISTER
2023           /* However only do this if we can be sure that this input
2024              operand doesn't correspond with an uninitialized pseudo.
2025              global can assign some hardreg to it that is the same as
2026              the one assigned to a different, also live pseudo (as it
2027              can ignore the conflict).  We must never introduce writes
2028              to such hardregs, as they would clobber the other live
2029              pseudo.  See PR 20973.  */
2030           || (!bitmap_bit_p (DF_LR_OUT (ENTRY_BLOCK_PTR),
2031                              ORIGINAL_REGNO (in))
2032               /* Similarly, only do this if we can be sure that the death
2033                  note is still valid.  global can assign some hardreg to
2034                  the pseudo referenced in the note and simultaneously a
2035                  subword of this hardreg to a different, also live pseudo,
2036                  because only another subword of the hardreg is actually
2037                  used in the insn.  This cannot happen if the pseudo has
2038                  been assigned exactly one hardreg.  See PR 33732.  */
2039               && hard_regno_nregs[REGNO (in)][GET_MODE (in)] == 1)))
2040     {
2041       unsigned int regno = REGNO (in) + in_offset;
2042       unsigned int nwords = hard_regno_nregs[regno][inmode];
2043
2044       if (! refers_to_regno_for_reload_p (regno, regno + nwords, out, (rtx*) 0)
2045           && ! hard_reg_set_here_p (regno, regno + nwords,
2046                                     PATTERN (this_insn))
2047           && (! earlyclobber
2048               || ! refers_to_regno_for_reload_p (regno, regno + nwords,
2049                                                  PATTERN (this_insn), inloc)))
2050         {
2051           unsigned int i;
2052
2053           for (i = 0; i < nwords; i++)
2054             if (! TEST_HARD_REG_BIT (reg_class_contents[(int) rclass],
2055                                      regno + i))
2056               break;
2057
2058           if (i == nwords)
2059             {
2060               /* If we were going to use OUT as the reload reg
2061                  and changed our mind, it means OUT is a dummy that
2062                  dies here.  So don't bother copying value to it.  */
2063               if (for_real >= 0 && value == real_out)
2064                 rld[for_real].out = 0;
2065               if (REG_P (real_in))
2066                 value = real_in;
2067               else
2068                 value = gen_rtx_REG (inmode, regno);
2069             }
2070         }
2071     }
2072
2073   return value;
2074 }
2075 \f
2076 /* This page contains subroutines used mainly for determining
2077    whether the IN or an OUT of a reload can serve as the
2078    reload register.  */
2079
2080 /* Return 1 if X is an operand of an insn that is being earlyclobbered.  */
2081
2082 int
2083 earlyclobber_operand_p (rtx x)
2084 {
2085   int i;
2086
2087   for (i = 0; i < n_earlyclobbers; i++)
2088     if (reload_earlyclobbers[i] == x)
2089       return 1;
2090
2091   return 0;
2092 }
2093
2094 /* Return 1 if expression X alters a hard reg in the range
2095    from BEG_REGNO (inclusive) to END_REGNO (exclusive),
2096    either explicitly or in the guise of a pseudo-reg allocated to REGNO.
2097    X should be the body of an instruction.  */
2098
2099 static int
2100 hard_reg_set_here_p (unsigned int beg_regno, unsigned int end_regno, rtx x)
2101 {
2102   if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
2103     {
2104       rtx op0 = SET_DEST (x);
2105
2106       while (GET_CODE (op0) == SUBREG)
2107         op0 = SUBREG_REG (op0);
2108       if (REG_P (op0))
2109         {
2110           unsigned int r = REGNO (op0);
2111
2112           /* See if this reg overlaps range under consideration.  */
2113           if (r < end_regno
2114               && end_hard_regno (GET_MODE (op0), r) > beg_regno)
2115             return 1;
2116         }
2117     }
2118   else if (GET_CODE (x) == PARALLEL)
2119     {
2120       int i = XVECLEN (x, 0) - 1;
2121
2122       for (; i >= 0; i--)
2123         if (hard_reg_set_here_p (beg_regno, end_regno, XVECEXP (x, 0, i)))
2124           return 1;
2125     }
2126
2127   return 0;
2128 }
2129
2130 /* Return 1 if ADDR is a valid memory address for mode MODE,
2131    and check that each pseudo reg has the proper kind of
2132    hard reg.  */
2133
2134 int
2135 strict_memory_address_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx addr)
2136 {
2137   GO_IF_LEGITIMATE_ADDRESS (mode, addr, win);
2138   return 0;
2139
2140  win:
2141   return 1;
2142 }
2143 \f
2144 /* Like rtx_equal_p except that it allows a REG and a SUBREG to match
2145    if they are the same hard reg, and has special hacks for
2146    autoincrement and autodecrement.
2147    This is specifically intended for find_reloads to use
2148    in determining whether two operands match.
2149    X is the operand whose number is the lower of the two.
2150
2151    The value is 2 if Y contains a pre-increment that matches
2152    a non-incrementing address in X.  */
2153
2154 /* ??? To be completely correct, we should arrange to pass
2155    for X the output operand and for Y the input operand.
2156    For now, we assume that the output operand has the lower number
2157    because that is natural in (SET output (... input ...)).  */
2158
2159 int
2160 operands_match_p (rtx x, rtx y)
2161 {
2162   int i;
2163   RTX_CODE code = GET_CODE (x);
2164   const char *fmt;
2165   int success_2;
2166
2167   if (x == y)
2168     return 1;
2169   if ((code == REG || (code == SUBREG && REG_P (SUBREG_REG (x))))
2170       && (REG_P (y) || (GET_CODE (y) == SUBREG
2171                                   && REG_P (SUBREG_REG (y)))))
2172     {
2173       int j;
2174
2175       if (code == SUBREG)
2176         {
2177           i = REGNO (SUBREG_REG (x));
2178           if (i >= FIRST_PSEUDO_REGISTER)
2179             goto slow;
2180           i += subreg_regno_offset (REGNO (SUBREG_REG (x)),
2181                                     GET_MODE (SUBREG_REG (x)),
2182                                     SUBREG_BYTE (x),
2183                                     GET_MODE (x));
2184         }
2185       else
2186         i = REGNO (x);
2187
2188       if (GET_CODE (y) == SUBREG)
2189         {
2190           j = REGNO (SUBREG_REG (y));
2191           if (j >= FIRST_PSEUDO_REGISTER)
2192             goto slow;
2193           j += subreg_regno_offset (REGNO (SUBREG_REG (y)),
2194                                     GET_MODE (SUBREG_REG (y)),
2195                                     SUBREG_BYTE (y),
2196                                     GET_MODE (y));
2197         }
2198       else
2199         j = REGNO (y);
2200
2201       /* On a WORDS_BIG_ENDIAN machine, point to the last register of a
2202          multiple hard register group of scalar integer registers, so that
2203          for example (reg:DI 0) and (reg:SI 1) will be considered the same
2204          register.  */
2205       if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD
2206           && SCALAR_INT_MODE_P (GET_MODE (x))
2207           && i < FIRST_PSEUDO_REGISTER)
2208         i += hard_regno_nregs[i][GET_MODE (x)] - 1;
2209       if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (y)) > UNITS_PER_WORD
2210           && SCALAR_INT_MODE_P (GET_MODE (y))
2211           && j < FIRST_PSEUDO_REGISTER)
2212         j += hard_regno_nregs[j][GET_MODE (y)] - 1;
2213
2214       return i == j;
2215     }
2216   /* If two operands must match, because they are really a single
2217      operand of an assembler insn, then two postincrements are invalid
2218      because the assembler insn would increment only once.
2219      On the other hand, a postincrement matches ordinary indexing
2220      if the postincrement is the output operand.  */
2221   if (code == POST_DEC || code == POST_INC || code == POST_MODIFY)
2222     return operands_match_p (XEXP (x, 0), y);
2223   /* Two preincrements are invalid
2224      because the assembler insn would increment only once.
2225      On the other hand, a preincrement matches ordinary indexing
2226      if the preincrement is the input operand.
2227      In this case, return 2, since some callers need to do special
2228      things when this happens.  */
2229   if (GET_CODE (y) == PRE_DEC || GET_CODE (y) == PRE_INC
2230       || GET_CODE (y) == PRE_MODIFY)
2231     return operands_match_p (x, XEXP (y, 0)) ? 2 : 0;
2232
2233  slow:
2234
2235   /* Now we have disposed of all the cases in which different rtx codes
2236      can match.  */
2237   if (code != GET_CODE (y))
2238     return 0;
2239
2240   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.  */
2241   if (GET_MODE (x) != GET_MODE (y))
2242     return 0;
2243
2244   switch (code)
2245     {
2246     case CONST_INT:
2247     case CONST_DOUBLE:
2248     case CONST_FIXED:
2249       return 0;
2250
2251     case LABEL_REF:
2252       return XEXP (x, 0) == XEXP (y, 0);
2253     case SYMBOL_REF:
2254       return XSTR (x, 0) == XSTR (y, 0);
2255
2256     default:
2257       break;
2258     }
2259
2260   /* Compare the elements.  If any pair of corresponding elements
2261      fail to match, return 0 for the whole things.  */
2262
2263   success_2 = 0;
2264   fmt = GET_RTX_FORMAT (code);
2265   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2266     {
2267       int val, j;
2268       switch (fmt[i])
2269         {
2270         case 'w':
2271           if (XWINT (x, i) != XWINT (y, i))
2272             return 0;
2273           break;
2274
2275         case 'i':
2276           if (XINT (x, i) != XINT (y, i))
2277             return 0;
2278           break;
2279
2280         case 'e':
2281           val = operands_match_p (XEXP (x, i), XEXP (y, i));
2282           if (val == 0)
2283             return 0;
2284           /* If any subexpression returns 2,
2285              we should return 2 if we are successful.  */
2286           if (val == 2)
2287             success_2 = 1;
2288           break;
2289
2290         case '0':
2291           break;
2292
2293         case 'E':
2294           if (XVECLEN (x, i) != XVECLEN (y, i))
2295             return 0;
2296           for (j = XVECLEN (x, i) - 1; j >= 0; --j)
2297             {
2298               val = operands_match_p (XVECEXP (x, i, j), XVECEXP (y, i, j));
2299               if (val == 0)
2300                 return 0;
2301               if (val == 2)
2302                 success_2 = 1;
2303             }
2304           break;
2305
2306           /* It is believed that rtx's at this level will never
2307              contain anything but integers and other rtx's,
2308              except for within LABEL_REFs and SYMBOL_REFs.  */
2309         default:
2310           gcc_unreachable ();
2311         }
2312     }
2313   return 1 + success_2;
2314 }
2315 \f
2316 /* Describe the range of registers or memory referenced by X.
2317    If X is a register, set REG_FLAG and put the first register
2318    number into START and the last plus one into END.
2319    If X is a memory reference, put a base address into BASE
2320    and a range of integer offsets into START and END.
2321    If X is pushing on the stack, we can assume it causes no trouble,
2322    so we set the SAFE field.  */
2323
2324 static struct decomposition
2325 decompose (rtx x)
2326 {
2327   struct decomposition val;
2328   int all_const = 0;
2329
2330   memset (&val, 0, sizeof (val));
2331
2332   switch (GET_CODE (x))
2333     {
2334     case MEM:
2335       {
2336         rtx base = NULL_RTX, offset = 0;
2337         rtx addr = XEXP (x, 0);
2338         
2339         if (GET_CODE (addr) == PRE_DEC || GET_CODE (addr) == PRE_INC
2340             || GET_CODE (addr) == POST_DEC || GET_CODE (addr) == POST_INC)
2341           {
2342             val.base = XEXP (addr, 0);
2343             val.start = -GET_MODE_SIZE (GET_MODE (x));
2344             val.end = GET_MODE_SIZE (GET_MODE (x));
2345             val.safe = REGNO (val.base) == STACK_POINTER_REGNUM;
2346             return val;
2347           }
2348         
2349         if (GET_CODE (addr) == PRE_MODIFY || GET_CODE (addr) == POST_MODIFY)
2350           {
2351             if (GET_CODE (XEXP (addr, 1)) == PLUS
2352                 && XEXP (addr, 0) == XEXP (XEXP (addr, 1), 0)
2353                 && CONSTANT_P (XEXP (XEXP (addr, 1), 1)))
2354               {
2355                 val.base  = XEXP (addr, 0);
2356                 val.start = -INTVAL (XEXP (XEXP (addr, 1), 1));
2357                 val.end   = INTVAL (XEXP (XEXP (addr, 1), 1));
2358                 val.safe  = REGNO (val.base) == STACK_POINTER_REGNUM;
2359                 return val;
2360               }
2361           }
2362         
2363         if (GET_CODE (addr) == CONST)
2364           {
2365             addr = XEXP (addr, 0);
2366             all_const = 1;
2367           }
2368         if (GET_CODE (addr) == PLUS)
2369           {
2370             if (CONSTANT_P (XEXP (addr, 0)))
2371               {
2372                 base = XEXP (addr, 1);
2373                 offset = XEXP (addr, 0);
2374               }
2375             else if (CONSTANT_P (XEXP (addr, 1)))
2376               {
2377                 base = XEXP (addr, 0);
2378                 offset = XEXP (addr, 1);
2379               }
2380           }
2381         
2382         if (offset == 0)
2383           {
2384             base = addr;
2385             offset = const0_rtx;
2386           }
2387         if (GET_CODE (offset) == CONST)
2388           offset = XEXP (offset, 0);
2389         if (GET_CODE (offset) == PLUS)
2390           {
2391             if (GET_CODE (XEXP (offset, 0)) == CONST_INT)
2392               {
2393                 base = gen_rtx_PLUS (GET_MODE (base), base, XEXP (offset, 1));
2394                 offset = XEXP (offset, 0);
2395               }
2396             else if (GET_CODE (XEXP (offset, 1)) == CONST_INT)
2397               {
2398                 base = gen_rtx_PLUS (GET_MODE (base), base, XEXP (offset, 0));
2399                 offset = XEXP (offset, 1);
2400               }
2401             else
2402               {
2403                 base = gen_rtx_PLUS (GET_MODE (base), base, offset);
2404                 offset = const0_rtx;
2405               }
2406           }
2407         else if (GET_CODE (offset) != CONST_INT)
2408           {
2409             base = gen_rtx_PLUS (GET_MODE (base), base, offset);
2410             offset = const0_rtx;
2411           }
2412         
2413         if (all_const && GET_CODE (base) == PLUS)
2414           base = gen_rtx_CONST (GET_MODE (base), base);
2415         
2416         gcc_assert (GET_CODE (offset) == CONST_INT);
2417         
2418         val.start = INTVAL (offset);
2419         val.end = val.start + GET_MODE_SIZE (GET_MODE (x));
2420         val.base = base;
2421       }
2422       break;
2423       
2424     case REG:
2425       val.reg_flag = 1;
2426       val.start = true_regnum (x);
2427       if (val.start < 0 || val.start >= FIRST_PSEUDO_REGISTER)
2428         {
2429           /* A pseudo with no hard reg.  */
2430           val.start = REGNO (x);
2431           val.end = val.start + 1;
2432         }
2433       else
2434         /* A hard reg.  */
2435         val.end = end_hard_regno (GET_MODE (x), val.start);
2436       break;
2437
2438     case SUBREG:
2439       if (!REG_P (SUBREG_REG (x)))
2440         /* This could be more precise, but it's good enough.  */
2441         return decompose (SUBREG_REG (x));
2442       val.reg_flag = 1;
2443       val.start = true_regnum (x);
2444       if (val.start < 0 || val.start >= FIRST_PSEUDO_REGISTER)
2445         return decompose (SUBREG_REG (x));
2446       else
2447         /* A hard reg.  */
2448         val.end = val.start + subreg_nregs (x);
2449       break;
2450
2451     case SCRATCH:
2452       /* This hasn't been assigned yet, so it can't conflict yet.  */
2453       val.safe = 1;
2454       break;
2455
2456     default:
2457       gcc_assert (CONSTANT_P (x));
2458       val.safe = 1;
2459       break;
2460     }
2461   return val;
2462 }
2463
2464 /* Return 1 if altering Y will not modify the value of X.
2465    Y is also described by YDATA, which should be decompose (Y).  */
2466
2467 static int
2468 immune_p (rtx x, rtx y, struct decomposition ydata)
2469 {
2470   struct decomposition xdata;
2471
2472   if (ydata.reg_flag)
2473     return !refers_to_regno_for_reload_p (ydata.start, ydata.end, x, (rtx*) 0);
2474   if (ydata.safe)
2475     return 1;
2476
2477   gcc_assert (MEM_P (y));
2478   /* If Y is memory and X is not, Y can't affect X.  */
2479   if (!MEM_P (x))
2480     return 1;
2481
2482   xdata = decompose (x);
2483
2484   if (! rtx_equal_p (xdata.base, ydata.base))
2485     {
2486       /* If bases are distinct symbolic constants, there is no overlap.  */
2487       if (CONSTANT_P (xdata.base) && CONSTANT_P (ydata.base))
2488         return 1;
2489       /* Constants and stack slots never overlap.  */
2490       if (CONSTANT_P (xdata.base)
2491           && (ydata.base == frame_pointer_rtx
2492               || ydata.base == hard_frame_pointer_rtx
2493               || ydata.base == stack_pointer_rtx))
2494         return 1;
2495       if (CONSTANT_P (ydata.base)
2496           && (xdata.base == frame_pointer_rtx
2497               || xdata.base == hard_frame_pointer_rtx
2498               || xdata.base == stack_pointer_rtx))
2499         return 1;
2500       /* If either base is variable, we don't know anything.  */
2501       return 0;
2502     }
2503
2504   return (xdata.start >= ydata.end || ydata.start >= xdata.end);
2505 }
2506
2507 /* Similar, but calls decompose.  */
2508
2509 int
2510 safe_from_earlyclobber (rtx op, rtx clobber)
2511 {
2512   struct decomposition early_data;
2513
2514   early_data = decompose (clobber);
2515   return immune_p (op, clobber, early_data);
2516 }
2517 \f
2518 /* Main entry point of this file: search the body of INSN
2519    for values that need reloading and record them with push_reload.
2520    REPLACE nonzero means record also where the values occur
2521    so that subst_reloads can be used.
2522
2523    IND_LEVELS says how many levels of indirection are supported by this
2524    machine; a value of zero means that a memory reference is not a valid
2525    memory address.
2526
2527    LIVE_KNOWN says we have valid information about which hard
2528    regs are live at each point in the program; this is true when
2529    we are called from global_alloc but false when stupid register
2530    allocation has been done.
2531
2532    RELOAD_REG_P if nonzero is a vector indexed by hard reg number
2533    which is nonnegative if the reg has been commandeered for reloading into.
2534    It is copied into STATIC_RELOAD_REG_P and referenced from there
2535    by various subroutines.
2536
2537    Return TRUE if some operands need to be changed, because of swapping
2538    commutative operands, reg_equiv_address substitution, or whatever.  */
2539
2540 int
2541 find_reloads (rtx insn, int replace, int ind_levels, int live_known,
2542               short *reload_reg_p)
2543 {
2544   int insn_code_number;
2545   int i, j;
2546   int noperands;
2547   /* These start out as the constraints for the insn
2548      and they are chewed up as we consider alternatives.  */
2549   const char *constraints[MAX_RECOG_OPERANDS];
2550   /* These are the preferred classes for an operand, or NO_REGS if it isn't
2551      a register.  */
2552   enum reg_class preferred_class[MAX_RECOG_OPERANDS];
2553   char pref_or_nothing[MAX_RECOG_OPERANDS];
2554   /* Nonzero for a MEM operand whose entire address needs a reload. 
2555      May be -1 to indicate the entire address may or may not need a reload.  */
2556   int address_reloaded[MAX_RECOG_OPERANDS];
2557   /* Nonzero for an address operand that needs to be completely reloaded.
2558      May be -1 to indicate the entire operand may or may not need a reload.  */
2559   int address_operand_reloaded[MAX_RECOG_OPERANDS];
2560   /* Value of enum reload_type to use for operand.  */
2561   enum reload_type operand_type[MAX_RECOG_OPERANDS];
2562   /* Value of enum reload_type to use within address of operand.  */
2563   enum reload_type address_type[MAX_RECOG_OPERANDS];
2564   /* Save the usage of each operand.  */
2565   enum reload_usage { RELOAD_READ, RELOAD_READ_WRITE, RELOAD_WRITE } modified[MAX_RECOG_OPERANDS];
2566   int no_input_reloads = 0, no_output_reloads = 0;
2567   int n_alternatives;
2568   int this_alternative[MAX_RECOG_OPERANDS];
2569   char this_alternative_match_win[MAX_RECOG_OPERANDS];
2570   char this_alternative_win[MAX_RECOG_OPERANDS];
2571   char this_alternative_offmemok[MAX_RECOG_OPERANDS];
2572   char this_alternative_earlyclobber[MAX_RECOG_OPERANDS];
2573   int this_alternative_matches[MAX_RECOG_OPERANDS];
2574   int swapped;
2575   int goal_alternative[MAX_RECOG_OPERANDS];
2576   int this_alternative_number;
2577   int goal_alternative_number = 0;
2578   int operand_reloadnum[MAX_RECOG_OPERANDS];
2579   int goal_alternative_matches[MAX_RECOG_OPERANDS];
2580   int goal_alternative_matched[MAX_RECOG_OPERANDS];
2581   char goal_alternative_match_win[MAX_RECOG_OPERANDS];
2582   char goal_alternative_win[MAX_RECOG_OPERANDS];
2583   char goal_alternative_offmemok[MAX_RECOG_OPERANDS];
2584   char goal_alternative_earlyclobber[MAX_RECOG_OPERANDS];
2585   int goal_alternative_swapped;
2586   int best;
2587   int commutative;
2588   char operands_match[MAX_RECOG_OPERANDS][MAX_RECOG_OPERANDS];
2589   rtx substed_operand[MAX_RECOG_OPERANDS];
2590   rtx body = PATTERN (insn);
2591   rtx set = single_set (insn);
2592   int goal_earlyclobber = 0, this_earlyclobber;
2593   enum machine_mode operand_mode[MAX_RECOG_OPERANDS];
2594   int retval = 0;
2595
2596   this_insn = insn;
2597   n_reloads = 0;
2598   n_replacements = 0;
2599   n_earlyclobbers = 0;
2600   replace_reloads = replace;
2601   hard_regs_live_known = live_known;
2602   static_reload_reg_p = reload_reg_p;
2603
2604   /* JUMP_INSNs and CALL_INSNs are not allowed to have any output reloads;
2605      neither are insns that SET cc0.  Insns that use CC0 are not allowed
2606      to have any input reloads.  */
2607   if (JUMP_P (insn) || CALL_P (insn))
2608     no_output_reloads = 1;
2609
2610 #ifdef HAVE_cc0
2611   if (reg_referenced_p (cc0_rtx, PATTERN (insn)))
2612     no_input_reloads = 1;
2613   if (reg_set_p (cc0_rtx, PATTERN (insn)))
2614     no_output_reloads = 1;
2615 #endif
2616
2617 #ifdef SECONDARY_MEMORY_NEEDED
2618   /* The eliminated forms of any secondary memory locations are per-insn, so
2619      clear them out here.  */
2620
2621   if (secondary_memlocs_elim_used)
2622     {
2623       memset (secondary_memlocs_elim, 0,
2624               sizeof (secondary_memlocs_elim[0]) * secondary_memlocs_elim_used);
2625       secondary_memlocs_elim_used = 0;
2626     }
2627 #endif
2628
2629   /* Dispose quickly of (set (reg..) (reg..)) if both have hard regs and it
2630      is cheap to move between them.  If it is not, there may not be an insn
2631      to do the copy, so we may need a reload.  */
2632   if (GET_CODE (body) == SET
2633       && REG_P (SET_DEST (body))
2634       && REGNO (SET_DEST (body)) < FIRST_PSEUDO_REGISTER
2635       && REG_P (SET_SRC (body))
2636       && REGNO (SET_SRC (body)) < FIRST_PSEUDO_REGISTER
2637       && REGISTER_MOVE_COST (GET_MODE (SET_SRC (body)),
2638                              REGNO_REG_CLASS (REGNO (SET_SRC (body))),
2639                              REGNO_REG_CLASS (REGNO (SET_DEST (body)))) == 2)
2640     return 0;
2641
2642   extract_insn (insn);
2643
2644   noperands = reload_n_operands = recog_data.n_operands;
2645   n_alternatives = recog_data.n_alternatives;
2646
2647   /* Just return "no reloads" if insn has no operands with constraints.  */
2648   if (noperands == 0 || n_alternatives == 0)
2649     return 0;
2650
2651   insn_code_number = INSN_CODE (insn);
2652   this_insn_is_asm = insn_code_number < 0;
2653
2654   memcpy (operand_mode, recog_data.operand_mode,
2655           noperands * sizeof (enum machine_mode));
2656   memcpy (constraints, recog_data.constraints,
2657           noperands * sizeof (const char *));
2658
2659   commutative = -1;
2660
2661   /* If we will need to know, later, whether some pair of operands
2662      are the same, we must compare them now and save the result.
2663      Reloading the base and index registers will clobber them
2664      and afterward they will fail to match.  */
2665
2666   for (i = 0; i < noperands; i++)
2667     {
2668       const char *p;
2669       int c;
2670       char *end;
2671
2672       substed_operand[i] = recog_data.operand[i];
2673       p = constraints[i];
2674
2675       modified[i] = RELOAD_READ;
2676
2677       /* Scan this operand's constraint to see if it is an output operand,
2678          an in-out operand, is commutative, or should match another.  */
2679
2680       while ((c = *p))
2681         {
2682           p += CONSTRAINT_LEN (c, p);
2683           switch (c)
2684             {
2685             case '=':
2686               modified[i] = RELOAD_WRITE;
2687               break;
2688             case '+':
2689               modified[i] = RELOAD_READ_WRITE;
2690               break;
2691             case '%':
2692               {
2693                 /* The last operand should not be marked commutative.  */
2694                 gcc_assert (i != noperands - 1);
2695
2696                 /* We currently only support one commutative pair of
2697                    operands.  Some existing asm code currently uses more
2698                    than one pair.  Previously, that would usually work,
2699                    but sometimes it would crash the compiler.  We
2700                    continue supporting that case as well as we can by
2701                    silently ignoring all but the first pair.  In the
2702                    future we may handle it correctly.  */
2703                 if (commutative < 0)
2704                   commutative = i;
2705                 else
2706                   gcc_assert (this_insn_is_asm);
2707               }
2708               break;
2709             /* Use of ISDIGIT is tempting here, but it may get expensive because
2710                of locale support we don't want.  */
2711             case '0': case '1': case '2': case '3': case '4':
2712             case '5': case '6': case '7': case '8': case '9':
2713               {
2714                 c = strtoul (p - 1, &end, 10);
2715                 p = end;
2716
2717                 operands_match[c][i]
2718                   = operands_match_p (recog_data.operand[c],
2719                                       recog_data.operand[i]);
2720
2721                 /* An operand may not match itself.  */
2722                 gcc_assert (c != i);
2723
2724                 /* If C can be commuted with C+1, and C might need to match I,
2725                    then C+1 might also need to match I.  */
2726                 if (commutative >= 0)
2727                   {
2728                     if (c == commutative || c == commutative + 1)
2729                       {
2730                         int other = c + (c == commutative ? 1 : -1);
2731                         operands_match[other][i]
2732                           = operands_match_p (recog_data.operand[other],
2733                                               recog_data.operand[i]);
2734                       }
2735                     if (i == commutative || i == commutative + 1)
2736                       {
2737                         int other = i + (i == commutative ? 1 : -1);
2738                         operands_match[c][other]
2739                           = operands_match_p (recog_data.operand[c],
2740                                               recog_data.operand[other]);
2741                       }
2742                     /* Note that C is supposed to be less than I.
2743                        No need to consider altering both C and I because in
2744                        that case we would alter one into the other.  */
2745                   }
2746               }
2747             }
2748         }
2749     }
2750
2751   /* Examine each operand that is a memory reference or memory address
2752      and reload parts of the addresses into index registers.
2753      Also here any references to pseudo regs that didn't get hard regs
2754      but are equivalent to constants get replaced in the insn itself
2755      with those constants.  Nobody will ever see them again.
2756
2757      Finally, set up the preferred classes of each operand.  */
2758
2759   for (i = 0; i < noperands; i++)
2760     {
2761       RTX_CODE code = GET_CODE (recog_data.operand[i]);
2762
2763       address_reloaded[i] = 0;
2764       address_operand_reloaded[i] = 0;
2765       operand_type[i] = (modified[i] == RELOAD_READ ? RELOAD_FOR_INPUT
2766                          : modified[i] == RELOAD_WRITE ? RELOAD_FOR_OUTPUT
2767                          : RELOAD_OTHER);
2768       address_type[i]
2769         = (modified[i] == RELOAD_READ ? RELOAD_FOR_INPUT_ADDRESS
2770            : modified[i] == RELOAD_WRITE ? RELOAD_FOR_OUTPUT_ADDRESS
2771            : RELOAD_OTHER);
2772
2773       if (*constraints[i] == 0)
2774         /* Ignore things like match_operator operands.  */
2775         ;
2776       else if (constraints[i][0] == 'p'
2777                || EXTRA_ADDRESS_CONSTRAINT (constraints[i][0], constraints[i]))
2778         {
2779           address_operand_reloaded[i]
2780             = find_reloads_address (recog_data.operand_mode[i], (rtx*) 0,
2781                                     recog_data.operand[i],
2782                                     recog_data.operand_loc[i],
2783                                     i, operand_type[i], ind_levels, insn);
2784
2785           /* If we now have a simple operand where we used to have a
2786              PLUS or MULT, re-recognize and try again.  */
2787           if ((OBJECT_P (*recog_data.operand_loc[i])
2788                || GET_CODE (*recog_data.operand_loc[i]) == SUBREG)
2789               && (GET_CODE (recog_data.operand[i]) == MULT
2790                   || GET_CODE (recog_data.operand[i]) == PLUS))
2791             {
2792               INSN_CODE (insn) = -1;
2793               retval = find_reloads (insn, replace, ind_levels, live_known,
2794                                      reload_reg_p);
2795               return retval;
2796             }
2797
2798           recog_data.operand[i] = *recog_data.operand_loc[i];
2799           substed_operand[i] = recog_data.operand[i];
2800
2801           /* Address operands are reloaded in their existing mode,
2802              no matter what is specified in the machine description.  */
2803           operand_mode[i] = GET_MODE (recog_data.operand[i]);
2804         }
2805       else if (code == MEM)
2806         {
2807           address_reloaded[i]
2808             = find_reloads_address (GET_MODE (recog_data.operand[i]),
2809                                     recog_data.operand_loc[i],
2810                                     XEXP (recog_data.operand[i], 0),
2811                                     &XEXP (recog_data.operand[i], 0),
2812                                     i, address_type[i], ind_levels, insn);
2813           recog_data.operand[i] = *recog_data.operand_loc[i];
2814           substed_operand[i] = recog_data.operand[i];
2815         }
2816       else if (code == SUBREG)
2817         {
2818           rtx reg = SUBREG_REG (recog_data.operand[i]);
2819           rtx op
2820             = find_reloads_toplev (recog_data.operand[i], i, address_type[i],
2821                                    ind_levels,
2822                                    set != 0
2823                                    && &SET_DEST (set) == recog_data.operand_loc[i],
2824                                    insn,
2825                                    &address_reloaded[i]);
2826
2827           /* If we made a MEM to load (a part of) the stackslot of a pseudo
2828              that didn't get a hard register, emit a USE with a REG_EQUAL
2829              note in front so that we might inherit a previous, possibly
2830              wider reload.  */
2831
2832           if (replace
2833               && MEM_P (op)
2834               && REG_P (reg)
2835               && (GET_MODE_SIZE (GET_MODE (reg))
2836                   >= GET_MODE_SIZE (GET_MODE (op)))
2837               && reg_equiv_constant[REGNO (reg)] == 0)
2838             set_unique_reg_note (emit_insn_before (gen_rtx_USE (VOIDmode, reg),
2839                                                    insn),
2840                                  REG_EQUAL, reg_equiv_memory_loc[REGNO (reg)]);
2841
2842           substed_operand[i] = recog_data.operand[i] = op;
2843         }
2844       else if (code == PLUS || GET_RTX_CLASS (code) == RTX_UNARY)
2845         /* We can get a PLUS as an "operand" as a result of register
2846            elimination.  See eliminate_regs and gen_reload.  We handle
2847            a unary operator by reloading the operand.  */
2848         substed_operand[i] = recog_data.operand[i]
2849           = find_reloads_toplev (recog_data.operand[i], i, address_type[i],
2850                                  ind_levels, 0, insn,
2851                                  &address_reloaded[i]);
2852       else if (code == REG)
2853         {
2854           /* This is equivalent to calling find_reloads_toplev.
2855              The code is duplicated for speed.
2856              When we find a pseudo always equivalent to a constant,
2857              we replace it by the constant.  We must be sure, however,
2858              that we don't try to replace it in the insn in which it
2859              is being set.  */
2860           int regno = REGNO (recog_data.operand[i]);
2861           if (reg_equiv_constant[regno] != 0
2862               && (set == 0 || &SET_DEST (set) != recog_data.operand_loc[i]))
2863             {
2864               /* Record the existing mode so that the check if constants are
2865                  allowed will work when operand_mode isn't specified.  */
2866
2867               if (operand_mode[i] == VOIDmode)
2868                 operand_mode[i] = GET_MODE (recog_data.operand[i]);
2869
2870               substed_operand[i] = recog_data.operand[i]
2871                 = reg_equiv_constant[regno];
2872             }
2873           if (reg_equiv_memory_loc[regno] != 0
2874               && (reg_equiv_address[regno] != 0 || num_not_at_initial_offset))
2875             /* We need not give a valid is_set_dest argument since the case
2876                of a constant equivalence was checked above.  */
2877             substed_operand[i] = recog_data.operand[i]
2878               = find_reloads_toplev (recog_data.operand[i], i, address_type[i],
2879                                      ind_levels, 0, insn,
2880                                      &address_reloaded[i]);
2881         }
2882       /* If the operand is still a register (we didn't replace it with an
2883          equivalent), get the preferred class to reload it into.  */
2884       code = GET_CODE (recog_data.operand[i]);
2885       preferred_class[i]
2886         = ((code == REG && REGNO (recog_data.operand[i])
2887             >= FIRST_PSEUDO_REGISTER)
2888            ? reg_preferred_class (REGNO (recog_data.operand[i]))
2889            : NO_REGS);
2890       pref_or_nothing[i]
2891         = (code == REG
2892            && REGNO (recog_data.operand[i]) >= FIRST_PSEUDO_REGISTER
2893            && reg_alternate_class (REGNO (recog_data.operand[i])) == NO_REGS);
2894     }
2895
2896   /* If this is simply a copy from operand 1 to operand 0, merge the
2897      preferred classes for the operands.  */
2898   if (set != 0 && noperands >= 2 && recog_data.operand[0] == SET_DEST (set)
2899       && recog_data.operand[1] == SET_SRC (set))
2900     {
2901       preferred_class[0] = preferred_class[1]
2902         = reg_class_subunion[(int) preferred_class[0]][(int) preferred_class[1]];
2903       pref_or_nothing[0] |= pref_or_nothing[1];
2904       pref_or_nothing[1] |= pref_or_nothing[0];
2905     }
2906
2907   /* Now see what we need for pseudo-regs that didn't get hard regs
2908      or got the wrong kind of hard reg.  For this, we must consider
2909      all the operands together against the register constraints.  */
2910
2911   best = MAX_RECOG_OPERANDS * 2 + 600;
2912
2913   swapped = 0;
2914   goal_alternative_swapped = 0;
2915  try_swapped:
2916
2917   /* The constraints are made of several alternatives.
2918      Each operand's constraint looks like foo,bar,... with commas
2919      separating the alternatives.  The first alternatives for all
2920      operands go together, the second alternatives go together, etc.
2921
2922      First loop over alternatives.  */
2923
2924   for (this_alternative_number = 0;
2925        this_alternative_number < n_alternatives;
2926        this_alternative_number++)
2927     {
2928       /* Loop over operands for one constraint alternative.  */
2929       /* LOSERS counts those that don't fit this alternative
2930          and would require loading.  */
2931       int losers = 0;
2932       /* BAD is set to 1 if it some operand can't fit this alternative
2933          even after reloading.  */
2934       int bad = 0;
2935       /* REJECT is a count of how undesirable this alternative says it is
2936          if any reloading is required.  If the alternative matches exactly
2937          then REJECT is ignored, but otherwise it gets this much
2938          counted against it in addition to the reloading needed.  Each
2939          ? counts three times here since we want the disparaging caused by
2940          a bad register class to only count 1/3 as much.  */
2941       int reject = 0;
2942
2943       if (!recog_data.alternative_enabled_p[this_alternative_number])
2944         {
2945           int i;
2946
2947           for (i = 0; i < recog_data.n_operands; i++)
2948             constraints[i] = skip_alternative (constraints[i]);
2949
2950           continue;
2951         }
2952
2953       this_earlyclobber = 0;
2954
2955       for (i = 0; i < noperands; i++)
2956         {
2957           const char *p = constraints[i];
2958           char *end;
2959           int len;
2960           int win = 0;
2961           int did_match = 0;
2962           /* 0 => this operand can be reloaded somehow for this alternative.  */
2963           int badop = 1;
2964           /* 0 => this operand can be reloaded if the alternative allows regs.  */
2965           int winreg = 0;
2966           int c;
2967           int m;
2968           rtx operand = recog_data.operand[i];
2969           int offset = 0;
2970           /* Nonzero means this is a MEM that must be reloaded into a reg
2971              regardless of what the constraint says.  */
2972           int force_reload = 0;
2973           int offmemok = 0;
2974           /* Nonzero if a constant forced into memory would be OK for this
2975              operand.  */
2976           int constmemok = 0;
2977           int earlyclobber = 0;
2978
2979           /* If the predicate accepts a unary operator, it means that
2980              we need to reload the operand, but do not do this for
2981              match_operator and friends.  */
2982           if (UNARY_P (operand) && *p != 0)
2983             operand = XEXP (operand, 0);
2984
2985           /* If the operand is a SUBREG, extract
2986              the REG or MEM (or maybe even a constant) within.
2987              (Constants can occur as a result of reg_equiv_constant.)  */
2988
2989           while (GET_CODE (operand) == SUBREG)
2990             {
2991               /* Offset only matters when operand is a REG and
2992                  it is a hard reg.  This is because it is passed
2993                  to reg_fits_class_p if it is a REG and all pseudos
2994                  return 0 from that function.  */
2995               if (REG_P (SUBREG_REG (operand))
2996                   && REGNO (SUBREG_REG (operand)) < FIRST_PSEUDO_REGISTER)
2997                 {
2998                   if (simplify_subreg_regno (REGNO (SUBREG_REG (operand)),
2999                                              GET_MODE (SUBREG_REG (operand)),
3000                                              SUBREG_BYTE (operand),
3001                                              GET_MODE (operand)) < 0)
3002                     force_reload = 1;
3003                   offset += subreg_regno_offset (REGNO (SUBREG_REG (operand)),
3004                                                  GET_MODE (SUBREG_REG (operand)),
3005                                                  SUBREG_BYTE (operand),
3006                                                  GET_MODE (operand));
3007                 }
3008               operand = SUBREG_REG (operand);
3009               /* Force reload if this is a constant or PLUS or if there may
3010                  be a problem accessing OPERAND in the outer mode.  */
3011               if (CONSTANT_P (operand)
3012                   || GET_CODE (operand) == PLUS
3013                   /* We must force a reload of paradoxical SUBREGs
3014                      of a MEM because the alignment of the inner value
3015                      may not be enough to do the outer reference.  On
3016                      big-endian machines, it may also reference outside
3017                      the object.
3018
3019                      On machines that extend byte operations and we have a
3020                      SUBREG where both the inner and outer modes are no wider
3021                      than a word and the inner mode is narrower, is integral,
3022                      and gets extended when loaded from memory, combine.c has
3023                      made assumptions about the behavior of the machine in such
3024                      register access.  If the data is, in fact, in memory we
3025                      must always load using the size assumed to be in the
3026                      register and let the insn do the different-sized
3027                      accesses.
3028
3029                      This is doubly true if WORD_REGISTER_OPERATIONS.  In
3030                      this case eliminate_regs has left non-paradoxical
3031                      subregs for push_reload to see.  Make sure it does
3032                      by forcing the reload.
3033
3034                      ??? When is it right at this stage to have a subreg
3035                      of a mem that is _not_ to be handled specially?  IMO
3036                      those should have been reduced to just a mem.  */
3037                   || ((MEM_P (operand)
3038                        || (REG_P (operand)
3039                            && REGNO (operand) >= FIRST_PSEUDO_REGISTER))
3040 #ifndef WORD_REGISTER_OPERATIONS
3041                       && (((GET_MODE_BITSIZE (GET_MODE (operand))
3042                             < BIGGEST_ALIGNMENT)
3043                            && (GET_MODE_SIZE (operand_mode[i])
3044                                > GET_MODE_SIZE (GET_MODE (operand))))
3045                           || BYTES_BIG_ENDIAN
3046 #ifdef LOAD_EXTEND_OP
3047                           || (GET_MODE_SIZE (operand_mode[i]) <= UNITS_PER_WORD
3048                               && (GET_MODE_SIZE (GET_MODE (operand))
3049                                   <= UNITS_PER_WORD)
3050                               && (GET_MODE_SIZE (operand_mode[i])
3051                                   > GET_MODE_SIZE (GET_MODE (operand)))
3052                               && INTEGRAL_MODE_P (GET_MODE (operand))
3053                               && LOAD_EXTEND_OP (GET_MODE (operand)) != UNKNOWN)
3054 #endif
3055                           )
3056 #endif
3057                       )
3058                   )
3059                 force_reload = 1;
3060             }
3061
3062           this_alternative[i] = (int) NO_REGS;
3063           this_alternative_win[i] = 0;
3064           this_alternative_match_win[i] = 0;
3065           this_alternative_offmemok[i] = 0;
3066           this_alternative_earlyclobber[i] = 0;
3067           this_alternative_matches[i] = -1;
3068
3069           /* An empty constraint or empty alternative
3070              allows anything which matched the pattern.  */
3071           if (*p == 0 || *p == ',')
3072             win = 1, badop = 0;
3073
3074           /* Scan this alternative's specs for this operand;
3075              set WIN if the operand fits any letter in this alternative.
3076              Otherwise, clear BADOP if this operand could
3077              fit some letter after reloads,
3078              or set WINREG if this operand could fit after reloads
3079              provided the constraint allows some registers.  */
3080
3081           do
3082             switch ((c = *p, len = CONSTRAINT_LEN (c, p)), c)
3083               {
3084               case '\0':
3085                 len = 0;
3086                 break;
3087               case ',':
3088                 c = '\0';
3089                 break;
3090
3091               case '=':  case '+':  case '*':
3092                 break;
3093
3094               case '%':
3095                 /* We only support one commutative marker, the first
3096                    one.  We already set commutative above.  */
3097                 break;
3098
3099               case '?':
3100                 reject += 6;
3101                 break;
3102
3103               case '!':
3104                 reject = 600;
3105                 break;
3106
3107               case '#':
3108                 /* Ignore rest of this alternative as far as
3109                    reloading is concerned.  */
3110                 do
3111                   p++;
3112                 while (*p && *p != ',');
3113                 len = 0;
3114                 break;
3115
3116               case '0':  case '1':  case '2':  case '3':  case '4':
3117               case '5':  case '6':  case '7':  case '8':  case '9':
3118                 m = strtoul (p, &end, 10);
3119                 p = end;
3120                 len = 0;
3121
3122                 this_alternative_matches[i] = m;
3123                 /* We are supposed to match a previous operand.
3124                    If we do, we win if that one did.
3125                    If we do not, count both of the operands as losers.
3126                    (This is too conservative, since most of the time
3127                    only a single reload insn will be needed to make
3128                    the two operands win.  As a result, this alternative
3129                    may be rejected when it is actually desirable.)  */
3130                 if ((swapped && (m != commutative || i != commutative + 1))
3131                     /* If we are matching as if two operands were swapped,
3132                        also pretend that operands_match had been computed
3133                        with swapped.
3134                        But if I is the second of those and C is the first,
3135                        don't exchange them, because operands_match is valid
3136                        only on one side of its diagonal.  */
3137                     ? (operands_match
3138                        [(m == commutative || m == commutative + 1)
3139                        ? 2 * commutative + 1 - m : m]
3140                        [(i == commutative || i == commutative + 1)
3141                        ? 2 * commutative + 1 - i : i])
3142                     : operands_match[m][i])
3143                   {
3144                     /* If we are matching a non-offsettable address where an
3145                        offsettable address was expected, then we must reject
3146                        this combination, because we can't reload it.  */
3147                     if (this_alternative_offmemok[m]
3148                         && MEM_P (recog_data.operand[m])
3149                         && this_alternative[m] == (int) NO_REGS
3150                         && ! this_alternative_win[m])
3151                       bad = 1;
3152
3153                     did_match = this_alternative_win[m];
3154                   }
3155                 else
3156                   {
3157                     /* Operands don't match.  */
3158                     rtx value;
3159                     int loc1, loc2;
3160                     /* Retroactively mark the operand we had to match
3161                        as a loser, if it wasn't already.  */
3162                     if (this_alternative_win[m])
3163                       losers++;
3164                     this_alternative_win[m] = 0;
3165                     if (this_alternative[m] == (int) NO_REGS)
3166                       bad = 1;
3167                     /* But count the pair only once in the total badness of
3168                        this alternative, if the pair can be a dummy reload.
3169                        The pointers in operand_loc are not swapped; swap
3170                        them by hand if necessary.  */
3171                     if (swapped && i == commutative)
3172                       loc1 = commutative + 1;
3173                     else if (swapped && i == commutative + 1)
3174                       loc1 = commutative;
3175                     else
3176                       loc1 = i;
3177                     if (swapped && m == commutative)
3178                       loc2 = commutative + 1;
3179                     else if (swapped && m == commutative + 1)
3180                       loc2 = commutative;
3181                     else
3182                       loc2 = m;
3183                     value
3184                       = find_dummy_reload (recog_data.operand[i],
3185                                            recog_data.operand[m],
3186                                            recog_data.operand_loc[loc1],
3187                                            recog_data.operand_loc[loc2],
3188                                            operand_mode[i], operand_mode[m],
3189                                            this_alternative[m], -1,
3190                                            this_alternative_earlyclobber[m]);
3191
3192                     if (value != 0)
3193                       losers--;
3194                   }
3195                 /* This can be fixed with reloads if the operand
3196                    we are supposed to match can be fixed with reloads.  */
3197                 badop = 0;
3198                 this_alternative[i] = this_alternative[m];
3199
3200                 /* If we have to reload this operand and some previous
3201                    operand also had to match the same thing as this
3202                    operand, we don't know how to do that.  So reject this
3203                    alternative.  */
3204                 if (! did_match || force_reload)
3205                   for (j = 0; j < i; j++)
3206                     if (this_alternative_matches[j]
3207                         == this_alternative_matches[i])
3208                       badop = 1;
3209                 break;
3210
3211               case 'p':
3212                 /* All necessary reloads for an address_operand
3213                    were handled in find_reloads_address.  */
3214                 this_alternative[i]
3215                   = (int) base_reg_class (VOIDmode, ADDRESS, SCRATCH);
3216                 win = 1;
3217                 badop = 0;
3218                 break;
3219
3220               case TARGET_MEM_CONSTRAINT:
3221                 if (force_reload)
3222                   break;
3223                 if (MEM_P (operand)
3224                     || (REG_P (operand)
3225                         && REGNO (operand) >= FIRST_PSEUDO_REGISTER
3226                         && reg_renumber[REGNO (operand)] < 0))
3227                   win = 1;
3228                 if (CONST_POOL_OK_P (operand))
3229                   badop = 0;
3230                 constmemok = 1;
3231                 break;
3232
3233               case '<':
3234                 if (MEM_P (operand)
3235                     && ! address_reloaded[i]
3236                     && (GET_CODE (XEXP (operand, 0)) == PRE_DEC
3237                         || GET_CODE (XEXP (operand, 0)) == POST_DEC))
3238                   win = 1;
3239                 break;
3240
3241               case '>':
3242                 if (MEM_P (operand)
3243                     && ! address_reloaded[i]
3244                     && (GET_CODE (XEXP (operand, 0)) == PRE_INC
3245                         || GET_CODE (XEXP (operand, 0)) == POST_INC))
3246                   win = 1;
3247                 break;
3248
3249                 /* Memory operand whose address is not offsettable.  */
3250               case 'V':
3251                 if (force_reload)
3252                   break;
3253                 if (MEM_P (operand)
3254                     && ! (ind_levels ? offsettable_memref_p (operand)
3255                           : offsettable_nonstrict_memref_p (operand))
3256                     /* Certain mem addresses will become offsettable
3257                        after they themselves are reloaded.  This is important;
3258                        we don't want our own handling of unoffsettables
3259                        to override the handling of reg_equiv_address.  */
3260                     && !(REG_P (XEXP (operand, 0))
3261                          && (ind_levels == 0
3262                              || reg_equiv_address[REGNO (XEXP (operand, 0))] != 0)))
3263                   win = 1;
3264                 break;
3265
3266                 /* Memory operand whose address is offsettable.  */
3267               case 'o':
3268                 if (force_reload)
3269                   break;
3270                 if ((MEM_P (operand)
3271                      /* If IND_LEVELS, find_reloads_address won't reload a
3272                         pseudo that didn't get a hard reg, so we have to
3273                         reject that case.  */
3274                      && ((ind_levels ? offsettable_memref_p (operand)
3275                           : offsettable_nonstrict_memref_p (operand))
3276                          /* A reloaded address is offsettable because it is now
3277                             just a simple register indirect.  */
3278                          || address_reloaded[i] == 1))
3279                     || (REG_P (operand)
3280                         && REGNO (operand) >= FIRST_PSEUDO_REGISTER
3281                         && reg_renumber[REGNO (operand)] < 0
3282                         /* If reg_equiv_address is nonzero, we will be
3283                            loading it into a register; hence it will be
3284                            offsettable, but we cannot say that reg_equiv_mem
3285                            is offsettable without checking.  */
3286                         && ((reg_equiv_mem[REGNO (operand)] != 0
3287                              && offsettable_memref_p (reg_equiv_mem[REGNO (operand)]))
3288                             || (reg_equiv_address[REGNO (operand)] != 0))))
3289                   win = 1;
3290                 if (CONST_POOL_OK_P (operand)
3291                     || MEM_P (operand))
3292                   badop = 0;
3293                 constmemok = 1;
3294                 offmemok = 1;
3295                 break;
3296
3297               case '&':
3298                 /* Output operand that is stored before the need for the
3299                    input operands (and their index registers) is over.  */
3300                 earlyclobber = 1, this_earlyclobber = 1;
3301                 break;
3302
3303               case 'E':
3304               case 'F':
3305                 if (GET_CODE (operand) == CONST_DOUBLE
3306                     || (GET_CODE (operand) == CONST_VECTOR
3307                         && (GET_MODE_CLASS (GET_MODE (operand))
3308                             == MODE_VECTOR_FLOAT)))
3309                   win = 1;
3310                 break;
3311
3312               case 'G':
3313               case 'H':
3314                 if (GET_CODE (operand) == CONST_DOUBLE
3315                     && CONST_DOUBLE_OK_FOR_CONSTRAINT_P (operand, c, p))
3316                   win = 1;
3317                 break;
3318
3319               case 's':
3320                 if (GET_CODE (operand) == CONST_INT
3321                     || (GET_CODE (operand) == CONST_DOUBLE
3322                         && GET_MODE (operand) == VOIDmode))
3323                   break;
3324               case 'i':
3325                 if (CONSTANT_P (operand)
3326                     && (! flag_pic || LEGITIMATE_PIC_OPERAND_P (operand)))
3327                   win = 1;
3328                 break;
3329
3330               case 'n':
3331                 if (GET_CODE (operand) == CONST_INT
3332                     || (GET_CODE (operand) == CONST_DOUBLE
3333                         && GET_MODE (operand) == VOIDmode))
3334                   win = 1;
3335                 break;
3336
3337               case 'I':
3338               case 'J':
3339               case 'K':
3340               case 'L':
3341               case 'M':
3342               case 'N':
3343               case 'O':
3344               case 'P':
3345                 if (GET_CODE (operand) == CONST_INT
3346                     && CONST_OK_FOR_CONSTRAINT_P (INTVAL (operand), c, p))
3347                   win = 1;
3348                 break;
3349
3350               case 'X':
3351                 force_reload = 0;
3352                 win = 1;
3353                 break;
3354
3355               case 'g':
3356                 if (! force_reload
3357                     /* A PLUS is never a valid operand, but reload can make
3358                        it from a register when eliminating registers.  */
3359                     && GET_CODE (operand) != PLUS
3360                     /* A SCRATCH is not a valid operand.  */
3361                     && GET_CODE (operand) != SCRATCH
3362                     && (! CONSTANT_P (operand)
3363                         || ! flag_pic
3364                         || LEGITIMATE_PIC_OPERAND_P (operand))
3365                     && (GENERAL_REGS == ALL_REGS
3366                         || !REG_P (operand)
3367                         || (REGNO (operand) >= FIRST_PSEUDO_REGISTER
3368                             && reg_renumber[REGNO (operand)] < 0)))
3369                   win = 1;
3370                 /* Drop through into 'r' case.  */
3371
3372               case 'r':
3373                 this_alternative[i]
3374                   = (int) reg_class_subunion[this_alternative[i]][(int) GENERAL_REGS];
3375                 goto reg;
3376
3377               default:
3378                 if (REG_CLASS_FROM_CONSTRAINT (c, p) == NO_REGS)
3379                   {
3380 #ifdef EXTRA_CONSTRAINT_STR
3381                     if (EXTRA_MEMORY_CONSTRAINT (c, p))
3382                       {
3383                         if (force_reload)
3384                           break;
3385                         if (EXTRA_CONSTRAINT_STR (operand, c, p))
3386                           win = 1;
3387                         /* If the address was already reloaded,
3388                            we win as well.  */
3389                         else if (MEM_P (operand)
3390                                  && address_reloaded[i] == 1)
3391                           win = 1;
3392                         /* Likewise if the address will be reloaded because
3393                            reg_equiv_address is nonzero.  For reg_equiv_mem
3394                            we have to check.  */
3395                         else if (REG_P (operand)
3396                                  && REGNO (operand) >= FIRST_PSEUDO_REGISTER
3397                                  && reg_renumber[REGNO (operand)] < 0
3398                                  && ((reg_equiv_mem[REGNO (operand)] != 0
3399                                       && EXTRA_CONSTRAINT_STR (reg_equiv_mem[REGNO (operand)], c, p))
3400                                      || (reg_equiv_address[REGNO (operand)] != 0)))
3401                           win = 1;
3402
3403                         /* If we didn't already win, we can reload
3404                            constants via force_const_mem, and other
3405                            MEMs by reloading the address like for 'o'.  */
3406                         if (CONST_POOL_OK_P (operand)
3407                             || MEM_P (operand))
3408                           badop = 0;
3409                         constmemok = 1;
3410                         offmemok = 1;
3411                         break;
3412                       }
3413                     if (EXTRA_ADDRESS_CONSTRAINT (c, p))
3414                       {
3415                         if (EXTRA_CONSTRAINT_STR (operand, c, p))
3416                           win = 1;
3417
3418                         /* If we didn't already win, we can reload
3419                            the address into a base register.  */
3420                         this_alternative[i]
3421                           = (int) base_reg_class (VOIDmode, ADDRESS, SCRATCH);
3422                         badop = 0;
3423                         break;
3424                       }
3425
3426                     if (EXTRA_CONSTRAINT_STR (operand, c, p))
3427                       win = 1;
3428 #endif
3429                     break;
3430                   }
3431
3432                 this_alternative[i]
3433                   = (int) (reg_class_subunion
3434                            [this_alternative[i]]
3435                            [(int) REG_CLASS_FROM_CONSTRAINT (c, p)]);
3436               reg:
3437                 if (GET_MODE (operand) == BLKmode)
3438                   break;
3439                 winreg = 1;
3440                 if (REG_P (operand)
3441                     && reg_fits_class_p (operand, this_alternative[i],
3442                                          offset, GET_MODE (recog_data.operand[i])))
3443                   win = 1;
3444                 break;
3445               }
3446           while ((p += len), c);
3447
3448           constraints[i] = p;
3449
3450           /* If this operand could be handled with a reg,
3451              and some reg is allowed, then this operand can be handled.  */
3452           if (winreg && this_alternative[i] != (int) NO_REGS)
3453             badop = 0;
3454
3455           /* Record which operands fit this alternative.  */
3456           this_alternative_earlyclobber[i] = earlyclobber;
3457           if (win && ! force_reload)
3458             this_alternative_win[i] = 1;
3459           else if (did_match && ! force_reload)
3460             this_alternative_match_win[i] = 1;
3461           else
3462             {
3463               int const_to_mem = 0;
3464
3465               this_alternative_offmemok[i] = offmemok;
3466               losers++;
3467               if (badop)
3468                 bad = 1;
3469               /* Alternative loses if it has no regs for a reg operand.  */
3470               if (REG_P (operand)
3471                   && this_alternative[i] == (int) NO_REGS
3472                   && this_alternative_matches[i] < 0)
3473                 bad = 1;
3474
3475               /* If this is a constant that is reloaded into the desired
3476                  class by copying it to memory first, count that as another
3477                  reload.  This is consistent with other code and is
3478                  required to avoid choosing another alternative when
3479                  the constant is moved into memory by this function on
3480                  an early reload pass.  Note that the test here is
3481                  precisely the same as in the code below that calls
3482                  force_const_mem.  */
3483               if (CONST_POOL_OK_P (operand)
3484                   && ((PREFERRED_RELOAD_CLASS (operand,
3485                                                (enum reg_class) this_alternative[i])
3486                        == NO_REGS)
3487                       || no_input_reloads)
3488                   && operand_mode[i] != VOIDmode)
3489                 {
3490                   const_to_mem = 1;
3491                   if (this_alternative[i] != (int) NO_REGS)
3492                     losers++;
3493                 }
3494
3495               /* Alternative loses if it requires a type of reload not
3496                  permitted for this insn.  We can always reload SCRATCH
3497                  and objects with a REG_UNUSED note.  */
3498               if (GET_CODE (operand) != SCRATCH
3499                        && modified[i] != RELOAD_READ && no_output_reloads
3500                        && ! find_reg_note (insn, REG_UNUSED, operand))
3501                 bad = 1;
3502               else if (modified[i] != RELOAD_WRITE && no_input_reloads
3503                        && ! const_to_mem)
3504                 bad = 1;
3505
3506               /* If we can't reload this value at all, reject this
3507                  alternative.  Note that we could also lose due to
3508                  LIMIT_RELOAD_CLASS, but we don't check that
3509                  here.  */
3510
3511               if (! CONSTANT_P (operand)
3512                   && (enum reg_class) this_alternative[i] != NO_REGS)
3513                 {
3514                   if (PREFERRED_RELOAD_CLASS
3515                         (operand, (enum reg_class) this_alternative[i])
3516                       == NO_REGS)
3517                     reject = 600;
3518
3519 #ifdef PREFERRED_OUTPUT_RELOAD_CLASS
3520                   if (operand_type[i] == RELOAD_FOR_OUTPUT
3521                       && PREFERRED_OUTPUT_RELOAD_CLASS
3522                            (operand, (enum reg_class) this_alternative[i])
3523                          == NO_REGS)
3524                     reject = 600;
3525 #endif
3526                 }
3527
3528               /* We prefer to reload pseudos over reloading other things,
3529                  since such reloads may be able to be eliminated later.
3530                  If we are reloading a SCRATCH, we won't be generating any
3531                  insns, just using a register, so it is also preferred.
3532                  So bump REJECT in other cases.  Don't do this in the
3533                  case where we are forcing a constant into memory and
3534                  it will then win since we don't want to have a different
3535                  alternative match then.  */
3536               if (! (REG_P (operand)
3537                      && REGNO (operand) >= FIRST_PSEUDO_REGISTER)
3538                   && GET_CODE (operand) != SCRATCH
3539                   && ! (const_to_mem && constmemok))
3540                 reject += 2;
3541
3542               /* Input reloads can be inherited more often than output
3543                  reloads can be removed, so penalize output reloads.  */
3544               if (operand_type[i] != RELOAD_FOR_INPUT
3545                   && GET_CODE (operand) != SCRATCH)
3546                 reject++;
3547             }
3548
3549           /* If this operand is a pseudo register that didn't get a hard
3550              reg and this alternative accepts some register, see if the
3551              class that we want is a subset of the preferred class for this
3552              register.  If not, but it intersects that class, use the
3553              preferred class instead.  If it does not intersect the preferred
3554              class, show that usage of this alternative should be discouraged;
3555              it will be discouraged more still if the register is `preferred
3556              or nothing'.  We do this because it increases the chance of
3557              reusing our spill register in a later insn and avoiding a pair
3558              of memory stores and loads.
3559
3560              Don't bother with this if this alternative will accept this
3561              operand.
3562
3563              Don't do this for a multiword operand, since it is only a
3564              small win and has the risk of requiring more spill registers,
3565              which could cause a large loss.
3566
3567              Don't do this if the preferred class has only one register
3568              because we might otherwise exhaust the class.  */
3569
3570           if (! win && ! did_match
3571               && this_alternative[i] != (int) NO_REGS
3572               && GET_MODE_SIZE (operand_mode[i]) <= UNITS_PER_WORD
3573               && reg_class_size [(int) preferred_class[i]] > 0
3574               && ! SMALL_REGISTER_CLASS_P (preferred_class[i]))
3575             {
3576               if (! reg_class_subset_p (this_alternative[i],
3577                                         preferred_class[i]))
3578                 {
3579                   /* Since we don't have a way of forming the intersection,
3580                      we just do something special if the preferred class
3581                      is a subset of the class we have; that's the most
3582                      common case anyway.  */
3583                   if (reg_class_subset_p (preferred_class[i],
3584                                           this_alternative[i]))
3585                     this_alternative[i] = (int) preferred_class[i];
3586                   else
3587                     reject += (2 + 2 * pref_or_nothing[i]);
3588                 }
3589             }
3590         }
3591
3592       /* Now see if any output operands that are marked "earlyclobber"
3593          in this alternative conflict with any input operands
3594          or any memory addresses.  */
3595
3596       for (i = 0; i < noperands; i++)
3597         if (this_alternative_earlyclobber[i]
3598             && (this_alternative_win[i] || this_alternative_match_win[i]))
3599           {
3600             struct decomposition early_data;
3601
3602             early_data = decompose (recog_data.operand[i]);
3603
3604             gcc_assert (modified[i] != RELOAD_READ);
3605
3606             if (this_alternative[i] == NO_REGS)
3607               {
3608                 this_alternative_earlyclobber[i] = 0;
3609                 gcc_assert (this_insn_is_asm);
3610                 error_for_asm (this_insn,
3611                                "%<&%> constraint used with no register class");
3612               }
3613
3614             for (j = 0; j < noperands; j++)
3615               /* Is this an input operand or a memory ref?  */
3616               if ((MEM_P (recog_data.operand[j])
3617                    || modified[j] != RELOAD_WRITE)
3618                   && j != i
3619                   /* Ignore things like match_operator operands.  */
3620                   && *recog_data.constraints[j] != 0
3621                   /* Don't count an input operand that is constrained to match
3622                      the early clobber operand.  */
3623                   && ! (this_alternative_matches[j] == i
3624                         && rtx_equal_p (recog_data.operand[i],
3625                                         recog_data.operand[j]))
3626                   /* Is it altered by storing the earlyclobber operand?  */
3627                   && !immune_p (recog_data.operand[j], recog_data.operand[i],
3628                                 early_data))
3629                 {
3630                   /* If the output is in a non-empty few-regs class,
3631                      it's costly to reload it, so reload the input instead.  */
3632                   if (SMALL_REGISTER_CLASS_P (this_alternative[i])
3633                       && (REG_P (recog_data.operand[j])
3634                           || GET_CODE (recog_data.operand[j]) == SUBREG))
3635                     {
3636                       losers++;
3637                       this_alternative_win[j] = 0;
3638                       this_alternative_match_win[j] = 0;
3639                     }
3640                   else
3641                     break;
3642                 }
3643             /* If an earlyclobber operand conflicts with something,
3644                it must be reloaded, so request this and count the cost.  */
3645             if (j != noperands)
3646               {
3647                 losers++;
3648                 this_alternative_win[i] = 0;
3649                 this_alternative_match_win[j] = 0;
3650                 for (j = 0; j < noperands; j++)
3651                   if (this_alternative_matches[j] == i
3652                       && this_alternative_match_win[j])
3653                     {
3654                       this_alternative_win[j] = 0;
3655                       this_alternative_match_win[j] = 0;
3656                       losers++;
3657                     }
3658               }
3659           }
3660
3661       /* If one alternative accepts all the operands, no reload required,
3662          choose that alternative; don't consider the remaining ones.  */
3663       if (losers == 0)
3664         {
3665           /* Unswap these so that they are never swapped at `finish'.  */
3666           if (commutative >= 0)
3667             {
3668               recog_data.operand[commutative] = substed_operand[commutative];
3669               recog_data.operand[commutative + 1]
3670                 = substed_operand[commutative + 1];
3671             }
3672           for (i = 0; i < noperands; i++)
3673             {
3674               goal_alternative_win[i] = this_alternative_win[i];
3675               goal_alternative_match_win[i] = this_alternative_match_win[i];
3676               goal_alternative[i] = this_alternative[i];
3677               goal_alternative_offmemok[i] = this_alternative_offmemok[i];
3678               goal_alternative_matches[i] = this_alternative_matches[i];
3679               goal_alternative_earlyclobber[i]
3680                 = this_alternative_earlyclobber[i];
3681             }
3682           goal_alternative_number = this_alternative_number;
3683           goal_alternative_swapped = swapped;
3684           goal_earlyclobber = this_earlyclobber;
3685           goto finish;
3686         }
3687
3688       /* REJECT, set by the ! and ? constraint characters and when a register
3689          would be reloaded into a non-preferred class, discourages the use of
3690          this alternative for a reload goal.  REJECT is incremented by six
3691          for each ? and two for each non-preferred class.  */
3692       losers = losers * 6 + reject;
3693
3694       /* If this alternative can be made to work by reloading,
3695          and it needs less reloading than the others checked so far,
3696          record it as the chosen goal for reloading.  */
3697       if (! bad && best > losers)
3698         {
3699           for (i = 0; i < noperands; i++)
3700             {
3701               goal_alternative[i] = this_alternative[i];
3702               goal_alternative_win[i] = this_alternative_win[i];
3703               goal_alternative_match_win[i] = this_alternative_match_win[i];
3704               goal_alternative_offmemok[i] = this_alternative_offmemok[i];
3705               goal_alternative_matches[i] = this_alternative_matches[i];
3706               goal_alternative_earlyclobber[i]
3707                 = this_alternative_earlyclobber[i];
3708             }
3709           goal_alternative_swapped = swapped;
3710           best = losers;
3711           goal_alternative_number = this_alternative_number;
3712           goal_earlyclobber = this_earlyclobber;
3713         }
3714     }
3715
3716   /* If insn is commutative (it's safe to exchange a certain pair of operands)
3717      then we need to try each alternative twice,
3718      the second time matching those two operands
3719      as if we had exchanged them.
3720      To do this, really exchange them in operands.
3721
3722      If we have just tried the alternatives the second time,
3723      return operands to normal and drop through.  */
3724
3725   if (commutative >= 0)
3726     {
3727       swapped = !swapped;
3728       if (swapped)
3729         {
3730           enum reg_class tclass;
3731           int t;
3732
3733           recog_data.operand[commutative] = substed_operand[commutative + 1];
3734           recog_data.operand[commutative + 1] = substed_operand[commutative];
3735           /* Swap the duplicates too.  */
3736           for (i = 0; i < recog_data.n_dups; i++)
3737             if (recog_data.dup_num[i] == commutative
3738                 || recog_data.dup_num[i] == commutative + 1)
3739               *recog_data.dup_loc[i]
3740                  = recog_data.operand[(int) recog_data.dup_num[i]];
3741
3742           tclass = preferred_class[commutative];
3743           preferred_class[commutative] = preferred_class[commutative + 1];
3744           preferred_class[commutative + 1] = tclass;
3745
3746           t = pref_or_nothing[commutative];
3747           pref_or_nothing[commutative] = pref_or_nothing[commutative + 1];
3748           pref_or_nothing[commutative + 1] = t;
3749
3750           t = address_reloaded[commutative];
3751           address_reloaded[commutative] = address_reloaded[commutative + 1];
3752           address_reloaded[commutative + 1] = t;
3753
3754           memcpy (constraints, recog_data.constraints,
3755                   noperands * sizeof (const char *));
3756           goto try_swapped;
3757         }
3758       else
3759         {
3760           recog_data.operand[commutative] = substed_operand[commutative];
3761           recog_data.operand[commutative + 1]
3762             = substed_operand[commutative + 1];
3763           /* Unswap the duplicates too.  */
3764           for (i = 0; i < recog_data.n_dups; i++)
3765             if (recog_data.dup_num[i] == commutative
3766                 || recog_data.dup_num[i] == commutative + 1)
3767               *recog_data.dup_loc[i]
3768                  = recog_data.operand[(int) recog_data.dup_num[i]];
3769         }
3770     }
3771
3772   /* The operands don't meet the constraints.