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