OSDN Git Service

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