1 /* Search an insn for pseudo regs that must be in hard regs and are not.
2 Copyright (C) 1987, 88, 89, 92, 93, 94, 1995 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* This file contains subroutines used only from the file reload1.c.
22 It knows how to scan one insn for operands and values
23 that need to be copied into registers to make valid code.
24 It also finds other operands and values which are valid
25 but for which equivalent values in registers exist and
26 ought to be used instead.
28 Before processing the first insn of the function, call `init_reload'.
30 To scan an insn, call `find_reloads'. This does two things:
31 1. sets up tables describing which values must be reloaded
32 for this insn, and what kind of hard regs they must be reloaded into;
33 2. optionally record the locations where those values appear in
34 the data, so they can be replaced properly later.
35 This is done only if the second arg to `find_reloads' is nonzero.
37 The third arg to `find_reloads' specifies the number of levels
38 of indirect addressing supported by the machine. If it is zero,
39 indirect addressing is not valid. If it is one, (MEM (REG n))
40 is valid even if (REG n) did not get a hard register; if it is two,
41 (MEM (MEM (REG n))) is also valid even if (REG n) did not get a
42 hard register, and similarly for higher values.
44 Then you must choose the hard regs to reload those pseudo regs into,
45 and generate appropriate load insns before this insn and perhaps
46 also store insns after this insn. Set up the array `reload_reg_rtx'
47 to contain the REG rtx's for the registers you used. In some
48 cases `find_reloads' will return a nonzero value in `reload_reg_rtx'
49 for certain reloads. Then that tells you which register to use,
50 so you do not need to allocate one. But you still do need to add extra
51 instructions to copy the value into and out of that register.
53 Finally you must call `subst_reloads' to substitute the reload reg rtx's
54 into the locations already recorded.
58 find_reloads can alter the operands of the instruction it is called on.
60 1. Two operands of any sort may be interchanged, if they are in a
61 commutative instruction.
62 This happens only if find_reloads thinks the instruction will compile
65 2. Pseudo-registers that are equivalent to constants are replaced
66 with those constants if they are not in hard registers.
68 1 happens every time find_reloads is called.
69 2 happens only when REPLACE is 1, which is only when
70 actually doing the reloads, not when just counting them.
73 Using a reload register for several reloads in one insn:
75 When an insn has reloads, it is considered as having three parts:
76 the input reloads, the insn itself after reloading, and the output reloads.
77 Reloads of values used in memory addresses are often needed for only one part.
79 When this is so, reload_when_needed records which part needs the reload.
80 Two reloads for different parts of the insn can share the same reload
83 When a reload is used for addresses in multiple parts, or when it is
84 an ordinary operand, it is classified as RELOAD_OTHER, and cannot share
85 a register with any other reload. */
92 #include "insn-config.h"
93 #include "insn-codes.h"
97 #include "hard-reg-set.h"
101 #ifndef REGISTER_MOVE_COST
102 #define REGISTER_MOVE_COST(x, y) 2
105 /* The variables set up by `find_reloads' are:
107 n_reloads number of distinct reloads needed; max reload # + 1
108 tables indexed by reload number
109 reload_in rtx for value to reload from
110 reload_out rtx for where to store reload-reg afterward if nec
111 (often the same as reload_in)
112 reload_reg_class enum reg_class, saying what regs to reload into
113 reload_inmode enum machine_mode; mode this operand should have
114 when reloaded, on input.
115 reload_outmode enum machine_mode; mode this operand should have
116 when reloaded, on output.
117 reload_optional char, nonzero for an optional reload.
118 Optional reloads are ignored unless the
119 value is already sitting in a register.
120 reload_inc int, positive amount to increment or decrement by if
121 reload_in is a PRE_DEC, PRE_INC, POST_DEC, POST_INC.
122 Ignored otherwise (don't assume it is zero).
123 reload_in_reg rtx. A reg for which reload_in is the equivalent.
124 If reload_in is a symbol_ref which came from
125 reg_equiv_constant, then this is the pseudo
126 which has that symbol_ref as equivalent.
127 reload_reg_rtx rtx. This is the register to reload into.
128 If it is zero when `find_reloads' returns,
129 you must find a suitable register in the class
130 specified by reload_reg_class, and store here
131 an rtx for that register with mode from
132 reload_inmode or reload_outmode.
133 reload_nocombine char, nonzero if this reload shouldn't be
134 combined with another reload.
135 reload_opnum int, operand number being reloaded. This is
136 used to group related reloads and need not always
137 be equal to the actual operand number in the insn,
138 though it current will be; for in-out operands, it
139 is one of the two operand numbers.
140 reload_when_needed enum, classifies reload as needed either for
141 addressing an input reload, addressing an output,
142 for addressing a non-reloaded mem ref,
143 or for unspecified purposes (i.e., more than one
145 reload_secondary_p int, 1 if this is a secondary register for one
147 reload_secondary_in_reload
148 reload_secondary_out_reload
149 int, gives the reload number of a secondary
150 reload, when needed; otherwise -1
151 reload_secondary_in_icode
152 reload_secondary_out_icode
153 enum insn_code, if a secondary reload is required,
154 gives the INSN_CODE that uses the secondary
155 reload as a scratch register, or CODE_FOR_nothing
156 if the secondary reload register is to be an
157 intermediate register. */
160 rtx reload_in
[MAX_RELOADS
];
161 rtx reload_out
[MAX_RELOADS
];
162 enum reg_class reload_reg_class
[MAX_RELOADS
];
163 enum machine_mode reload_inmode
[MAX_RELOADS
];
164 enum machine_mode reload_outmode
[MAX_RELOADS
];
165 rtx reload_reg_rtx
[MAX_RELOADS
];
166 char reload_optional
[MAX_RELOADS
];
167 int reload_inc
[MAX_RELOADS
];
168 rtx reload_in_reg
[MAX_RELOADS
];
169 char reload_nocombine
[MAX_RELOADS
];
170 int reload_opnum
[MAX_RELOADS
];
171 enum reload_type reload_when_needed
[MAX_RELOADS
];
172 int reload_secondary_p
[MAX_RELOADS
];
173 int reload_secondary_in_reload
[MAX_RELOADS
];
174 int reload_secondary_out_reload
[MAX_RELOADS
];
175 enum insn_code reload_secondary_in_icode
[MAX_RELOADS
];
176 enum insn_code reload_secondary_out_icode
[MAX_RELOADS
];
178 /* All the "earlyclobber" operands of the current insn
179 are recorded here. */
181 rtx reload_earlyclobbers
[MAX_RECOG_OPERANDS
];
183 int reload_n_operands
;
185 /* Replacing reloads.
187 If `replace_reloads' is nonzero, then as each reload is recorded
188 an entry is made for it in the table `replacements'.
189 Then later `subst_reloads' can look through that table and
190 perform all the replacements needed. */
192 /* Nonzero means record the places to replace. */
193 static int replace_reloads
;
195 /* Each replacement is recorded with a structure like this. */
198 rtx
*where
; /* Location to store in */
199 rtx
*subreg_loc
; /* Location of SUBREG if WHERE is inside
200 a SUBREG; 0 otherwise. */
201 int what
; /* which reload this is for */
202 enum machine_mode mode
; /* mode it must have */
205 static struct replacement replacements
[MAX_RECOG_OPERANDS
* ((MAX_REGS_PER_ADDRESS
* 2) + 1)];
207 /* Number of replacements currently recorded. */
208 static int n_replacements
;
210 /* Used to track what is modified by an operand. */
213 int reg_flag
; /* Nonzero if referencing a register. */
214 int safe
; /* Nonzero if this can't conflict with anything. */
215 rtx base
; /* Base adddress for MEM. */
216 HOST_WIDE_INT start
; /* Starting offset or register number. */
217 HOST_WIDE_INT end
; /* Endinf offset or register number. */
220 /* MEM-rtx's created for pseudo-regs in stack slots not directly addressable;
221 (see reg_equiv_address). */
222 static rtx memlocs
[MAX_RECOG_OPERANDS
* ((MAX_REGS_PER_ADDRESS
* 2) + 1)];
223 static int n_memlocs
;
225 #ifdef SECONDARY_MEMORY_NEEDED
227 /* Save MEMs needed to copy from one class of registers to another. One MEM
228 is used per mode, but normally only one or two modes are ever used.
230 We keep two versions, before and after register elimination. The one
231 after register elimination is record separately for each operand. This
232 is done in case the address is not valid to be sure that we separately
235 static rtx secondary_memlocs
[NUM_MACHINE_MODES
];
236 static rtx secondary_memlocs_elim
[NUM_MACHINE_MODES
][MAX_RECOG_OPERANDS
];
239 /* The instruction we are doing reloads for;
240 so we can test whether a register dies in it. */
241 static rtx this_insn
;
243 /* Nonzero if this instruction is a user-specified asm with operands. */
244 static int this_insn_is_asm
;
246 /* If hard_regs_live_known is nonzero,
247 we can tell which hard regs are currently live,
248 at least enough to succeed in choosing dummy reloads. */
249 static int hard_regs_live_known
;
251 /* Indexed by hard reg number,
252 element is nonegative if hard reg has been spilled.
253 This vector is passed to `find_reloads' as an argument
254 and is not changed here. */
255 static short *static_reload_reg_p
;
257 /* Set to 1 in subst_reg_equivs if it changes anything. */
258 static int subst_reg_equivs_changed
;
260 /* On return from push_reload, holds the reload-number for the OUT
261 operand, which can be different for that from the input operand. */
262 static int output_reloadnum
;
264 /* Compare two RTX's. */
265 #define MATCHES(x, y) \
266 (x == y || (x != 0 && (GET_CODE (x) == REG \
267 ? GET_CODE (y) == REG && REGNO (x) == REGNO (y) \
268 : rtx_equal_p (x, y) && ! side_effects_p (x))))
270 /* Indicates if two reloads purposes are for similar enough things that we
271 can merge their reloads. */
272 #define MERGABLE_RELOADS(when1, when2, op1, op2) \
273 ((when1) == RELOAD_OTHER || (when2) == RELOAD_OTHER \
274 || ((when1) == (when2) && (op1) == (op2)) \
275 || ((when1) == RELOAD_FOR_INPUT && (when2) == RELOAD_FOR_INPUT) \
276 || ((when1) == RELOAD_FOR_OPERAND_ADDRESS \
277 && (when2) == RELOAD_FOR_OPERAND_ADDRESS) \
278 || ((when1) == RELOAD_FOR_OTHER_ADDRESS \
279 && (when2) == RELOAD_FOR_OTHER_ADDRESS))
281 /* Nonzero if these two reload purposes produce RELOAD_OTHER when merged. */
282 #define MERGE_TO_OTHER(when1, when2, op1, op2) \
283 ((when1) != (when2) \
284 || ! ((op1) == (op2) \
285 || (when1) == RELOAD_FOR_INPUT \
286 || (when1) == RELOAD_FOR_OPERAND_ADDRESS \
287 || (when1) == RELOAD_FOR_OTHER_ADDRESS))
289 static int push_secondary_reload
PROTO((int, rtx
, int, int, enum reg_class
,
290 enum machine_mode
, enum reload_type
,
292 static int push_reload
PROTO((rtx
, rtx
, rtx
*, rtx
*, enum reg_class
,
293 enum machine_mode
, enum machine_mode
,
294 int, int, int, enum reload_type
));
295 static void push_replacement
PROTO((rtx
*, int, enum machine_mode
));
296 static void combine_reloads
PROTO((void));
297 static rtx find_dummy_reload
PROTO((rtx
, rtx
, rtx
*, rtx
*,
298 enum machine_mode
, enum machine_mode
,
299 enum reg_class
, int));
300 static int earlyclobber_operand_p
PROTO((rtx
));
301 static int hard_reg_set_here_p
PROTO((int, int, rtx
));
302 static struct decomposition decompose
PROTO((rtx
));
303 static int immune_p
PROTO((rtx
, rtx
, struct decomposition
));
304 static int alternative_allows_memconst
PROTO((char *, int));
305 static rtx find_reloads_toplev
PROTO((rtx
, int, enum reload_type
, int, int));
306 static rtx make_memloc
PROTO((rtx
, int));
307 static int find_reloads_address
PROTO((enum machine_mode
, rtx
*, rtx
, rtx
*,
308 int, enum reload_type
, int));
309 static rtx subst_reg_equivs
PROTO((rtx
));
310 static rtx subst_indexed_address
PROTO((rtx
));
311 static int find_reloads_address_1
PROTO((rtx
, int, rtx
*, int,
312 enum reload_type
,int));
313 static void find_reloads_address_part
PROTO((rtx
, rtx
*, enum reg_class
,
314 enum machine_mode
, int,
315 enum reload_type
, int));
316 static int find_inc_amount
PROTO((rtx
, rtx
));
318 #ifdef HAVE_SECONDARY_RELOADS
320 /* Determine if any secondary reloads are needed for loading (if IN_P is
321 non-zero) or storing (if IN_P is zero) X to or from a reload register of
322 register class RELOAD_CLASS in mode RELOAD_MODE. If secondary reloads
323 are needed, push them.
325 Return the reload number of the secondary reload we made, or -1 if
326 we didn't need one. *PICODE is set to the insn_code to use if we do
327 need a secondary reload. */
330 push_secondary_reload (in_p
, x
, opnum
, optional
, reload_class
, reload_mode
,
336 enum reg_class reload_class
;
337 enum machine_mode reload_mode
;
338 enum reload_type type
;
339 enum insn_code
*picode
;
341 enum reg_class
class = NO_REGS
;
342 enum machine_mode mode
= reload_mode
;
343 enum insn_code icode
= CODE_FOR_nothing
;
344 enum reg_class t_class
= NO_REGS
;
345 enum machine_mode t_mode
= VOIDmode
;
346 enum insn_code t_icode
= CODE_FOR_nothing
;
347 enum reload_type secondary_type
;
349 int s_reload
, t_reload
= -1;
351 if (type
== RELOAD_FOR_INPUT_ADDRESS
|| type
== RELOAD_FOR_OUTPUT_ADDRESS
)
352 secondary_type
= type
;
354 secondary_type
= in_p
? RELOAD_FOR_INPUT_ADDRESS
: RELOAD_FOR_OUTPUT_ADDRESS
;
356 *picode
= CODE_FOR_nothing
;
358 /* If X is a pseudo-register that has an equivalent MEM (actually, if it
359 is still a pseudo-register by now, it *must* have an equivalent MEM
360 but we don't want to assume that), use that equivalent when seeing if
361 a secondary reload is needed since whether or not a reload is needed
362 might be sensitive to the form of the MEM. */
364 if (GET_CODE (x
) == REG
&& REGNO (x
) >= FIRST_PSEUDO_REGISTER
365 && reg_equiv_mem
[REGNO (x
)] != 0)
366 x
= reg_equiv_mem
[REGNO (x
)];
368 #ifdef SECONDARY_INPUT_RELOAD_CLASS
370 class = SECONDARY_INPUT_RELOAD_CLASS (reload_class
, reload_mode
, x
);
373 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
375 class = SECONDARY_OUTPUT_RELOAD_CLASS (reload_class
, reload_mode
, x
);
378 /* If we don't need any secondary registers, done. */
379 if (class == NO_REGS
)
382 /* Get a possible insn to use. If the predicate doesn't accept X, don't
385 icode
= (in_p
? reload_in_optab
[(int) reload_mode
]
386 : reload_out_optab
[(int) reload_mode
]);
388 if (icode
!= CODE_FOR_nothing
389 && insn_operand_predicate
[(int) icode
][in_p
]
390 && (! (insn_operand_predicate
[(int) icode
][in_p
]) (x
, reload_mode
)))
391 icode
= CODE_FOR_nothing
;
393 /* If we will be using an insn, see if it can directly handle the reload
394 register we will be using. If it can, the secondary reload is for a
395 scratch register. If it can't, we will use the secondary reload for
396 an intermediate register and require a tertiary reload for the scratch
399 if (icode
!= CODE_FOR_nothing
)
401 /* If IN_P is non-zero, the reload register will be the output in
402 operand 0. If IN_P is zero, the reload register will be the input
403 in operand 1. Outputs should have an initial "=", which we must
406 char insn_letter
= insn_operand_constraint
[(int) icode
][!in_p
][in_p
];
407 enum reg_class insn_class
408 = (insn_letter
== 'r' ? GENERAL_REGS
409 : REG_CLASS_FROM_LETTER (insn_letter
));
411 if (insn_class
== NO_REGS
412 || (in_p
&& insn_operand_constraint
[(int) icode
][!in_p
][0] != '=')
413 /* The scratch register's constraint must start with "=&". */
414 || insn_operand_constraint
[(int) icode
][2][0] != '='
415 || insn_operand_constraint
[(int) icode
][2][1] != '&')
418 if (reg_class_subset_p (reload_class
, insn_class
))
419 mode
= insn_operand_mode
[(int) icode
][2];
422 char t_letter
= insn_operand_constraint
[(int) icode
][2][2];
424 t_mode
= insn_operand_mode
[(int) icode
][2];
425 t_class
= (t_letter
== 'r' ? GENERAL_REGS
426 : REG_CLASS_FROM_LETTER (t_letter
));
428 icode
= CODE_FOR_nothing
;
432 /* This case isn't valid, so fail. Reload is allowed to use the same
433 register for RELOAD_FOR_INPUT_ADDRESS and RELOAD_FOR_INPUT reloads, but
434 in the case of a secondary register, we actually need two different
435 registers for correct code. We fail here to prevent the possibility of
436 silently generating incorrect code later.
438 The convention is that secondary input reloads are valid only if the
439 secondary_class is different from class. If you have such a case, you
440 can not use secondary reloads, you must work around the problem some
443 Allow this when MODE is not reload_mode and assume that the generated
444 code handles this case (it does on the Alpha, which is the only place
445 this currently happens). */
447 if (in_p
&& class == reload_class
&& mode
== reload_mode
)
450 /* If we need a tertiary reload, see if we have one we can reuse or else
453 if (t_class
!= NO_REGS
)
455 for (t_reload
= 0; t_reload
< n_reloads
; t_reload
++)
456 if (reload_secondary_p
[t_reload
]
457 && (reg_class_subset_p (t_class
, reload_reg_class
[t_reload
])
458 || reg_class_subset_p (reload_reg_class
[t_reload
], t_class
))
459 && ((in_p
&& reload_inmode
[t_reload
] == t_mode
)
460 || (! in_p
&& reload_outmode
[t_reload
] == t_mode
))
461 && ((in_p
&& (reload_secondary_in_icode
[t_reload
]
462 == CODE_FOR_nothing
))
463 || (! in_p
&&(reload_secondary_out_icode
[t_reload
]
464 == CODE_FOR_nothing
)))
465 && (reg_class_size
[(int) t_class
] == 1
466 #ifdef SMALL_REGISTER_CLASSES
470 && MERGABLE_RELOADS (secondary_type
,
471 reload_when_needed
[t_reload
],
472 opnum
, reload_opnum
[t_reload
]))
475 reload_inmode
[t_reload
] = t_mode
;
477 reload_outmode
[t_reload
] = t_mode
;
479 if (reg_class_subset_p (t_class
, reload_reg_class
[t_reload
]))
480 reload_reg_class
[t_reload
] = t_class
;
482 reload_opnum
[t_reload
] = MIN (reload_opnum
[t_reload
], opnum
);
483 reload_optional
[t_reload
] &= optional
;
484 reload_secondary_p
[t_reload
] = 1;
485 if (MERGE_TO_OTHER (secondary_type
, reload_when_needed
[t_reload
],
486 opnum
, reload_opnum
[t_reload
]))
487 reload_when_needed
[t_reload
] = RELOAD_OTHER
;
490 if (t_reload
== n_reloads
)
492 /* We need to make a new tertiary reload for this register class. */
493 reload_in
[t_reload
] = reload_out
[t_reload
] = 0;
494 reload_reg_class
[t_reload
] = t_class
;
495 reload_inmode
[t_reload
] = in_p
? t_mode
: VOIDmode
;
496 reload_outmode
[t_reload
] = ! in_p
? t_mode
: VOIDmode
;
497 reload_reg_rtx
[t_reload
] = 0;
498 reload_optional
[t_reload
] = optional
;
499 reload_inc
[t_reload
] = 0;
500 /* Maybe we could combine these, but it seems too tricky. */
501 reload_nocombine
[t_reload
] = 1;
502 reload_in_reg
[t_reload
] = 0;
503 reload_opnum
[t_reload
] = opnum
;
504 reload_when_needed
[t_reload
] = secondary_type
;
505 reload_secondary_in_reload
[t_reload
] = -1;
506 reload_secondary_out_reload
[t_reload
] = -1;
507 reload_secondary_in_icode
[t_reload
] = CODE_FOR_nothing
;
508 reload_secondary_out_icode
[t_reload
] = CODE_FOR_nothing
;
509 reload_secondary_p
[t_reload
] = 1;
515 /* See if we can reuse an existing secondary reload. */
516 for (s_reload
= 0; s_reload
< n_reloads
; s_reload
++)
517 if (reload_secondary_p
[s_reload
]
518 && (reg_class_subset_p (class, reload_reg_class
[s_reload
])
519 || reg_class_subset_p (reload_reg_class
[s_reload
], class))
520 && ((in_p
&& reload_inmode
[s_reload
] == mode
)
521 || (! in_p
&& reload_outmode
[s_reload
] == mode
))
522 && ((in_p
&& reload_secondary_in_reload
[s_reload
] == t_reload
)
523 || (! in_p
&& reload_secondary_out_reload
[s_reload
] == t_reload
))
524 && ((in_p
&& reload_secondary_in_icode
[s_reload
] == t_icode
)
525 || (! in_p
&& reload_secondary_out_icode
[s_reload
] == t_icode
))
526 && (reg_class_size
[(int) class] == 1
527 #ifdef SMALL_REGISTER_CLASSES
531 && MERGABLE_RELOADS (secondary_type
, reload_when_needed
[s_reload
],
532 opnum
, reload_opnum
[s_reload
]))
535 reload_inmode
[s_reload
] = mode
;
537 reload_outmode
[s_reload
] = mode
;
539 if (reg_class_subset_p (class, reload_reg_class
[s_reload
]))
540 reload_reg_class
[s_reload
] = class;
542 reload_opnum
[s_reload
] = MIN (reload_opnum
[s_reload
], opnum
);
543 reload_optional
[s_reload
] &= optional
;
544 reload_secondary_p
[s_reload
] = 1;
545 if (MERGE_TO_OTHER (secondary_type
, reload_when_needed
[s_reload
],
546 opnum
, reload_opnum
[s_reload
]))
547 reload_when_needed
[s_reload
] = RELOAD_OTHER
;
550 if (s_reload
== n_reloads
)
552 /* We need to make a new secondary reload for this register class. */
553 reload_in
[s_reload
] = reload_out
[s_reload
] = 0;
554 reload_reg_class
[s_reload
] = class;
556 reload_inmode
[s_reload
] = in_p
? mode
: VOIDmode
;
557 reload_outmode
[s_reload
] = ! in_p
? mode
: VOIDmode
;
558 reload_reg_rtx
[s_reload
] = 0;
559 reload_optional
[s_reload
] = optional
;
560 reload_inc
[s_reload
] = 0;
561 /* Maybe we could combine these, but it seems too tricky. */
562 reload_nocombine
[s_reload
] = 1;
563 reload_in_reg
[s_reload
] = 0;
564 reload_opnum
[s_reload
] = opnum
;
565 reload_when_needed
[s_reload
] = secondary_type
;
566 reload_secondary_in_reload
[s_reload
] = in_p
? t_reload
: -1;
567 reload_secondary_out_reload
[s_reload
] = ! in_p
? t_reload
: -1;
568 reload_secondary_in_icode
[s_reload
] = in_p
? t_icode
: CODE_FOR_nothing
;
569 reload_secondary_out_icode
[s_reload
]
570 = ! in_p
? t_icode
: CODE_FOR_nothing
;
571 reload_secondary_p
[s_reload
] = 1;
575 #ifdef SECONDARY_MEMORY_NEEDED
576 /* If we need a memory location to copy between the two reload regs,
579 if (in_p
&& icode
== CODE_FOR_nothing
580 && SECONDARY_MEMORY_NEEDED (class, reload_class
, reload_mode
))
581 get_secondary_mem (x
, reload_mode
, opnum
, type
);
583 if (! in_p
&& icode
== CODE_FOR_nothing
584 && SECONDARY_MEMORY_NEEDED (reload_class
, class, reload_mode
))
585 get_secondary_mem (x
, reload_mode
, opnum
, type
);
592 #endif /* HAVE_SECONDARY_RELOADS */
594 #ifdef SECONDARY_MEMORY_NEEDED
596 /* Return a memory location that will be used to copy X in mode MODE.
597 If we haven't already made a location for this mode in this insn,
598 call find_reloads_address on the location being returned. */
601 get_secondary_mem (x
, mode
, opnum
, type
)
603 enum machine_mode mode
;
605 enum reload_type type
;
610 /* By default, if MODE is narrower than a word, widen it to a word.
611 This is required because most machines that require these memory
612 locations do not support short load and stores from all registers
613 (e.g., FP registers). */
615 #ifdef SECONDARY_MEMORY_NEEDED_MODE
616 mode
= SECONDARY_MEMORY_NEEDED_MODE (mode
);
618 if (GET_MODE_BITSIZE (mode
) < BITS_PER_WORD
)
619 mode
= mode_for_size (BITS_PER_WORD
, GET_MODE_CLASS (mode
), 0);
622 /* If we already have made a MEM for this operand in MODE, return it. */
623 if (secondary_memlocs_elim
[(int) mode
][opnum
] != 0)
624 return secondary_memlocs_elim
[(int) mode
][opnum
];
626 /* If this is the first time we've tried to get a MEM for this mode,
627 allocate a new one. `something_changed' in reload will get set
628 by noticing that the frame size has changed. */
630 if (secondary_memlocs
[(int) mode
] == 0)
632 #ifdef SECONDARY_MEMORY_NEEDED_RTX
633 secondary_memlocs
[(int) mode
] = SECONDARY_MEMORY_NEEDED_RTX (mode
);
635 secondary_memlocs
[(int) mode
]
636 = assign_stack_local (mode
, GET_MODE_SIZE (mode
), 0);
640 /* Get a version of the address doing any eliminations needed. If that
641 didn't give us a new MEM, make a new one if it isn't valid. */
643 loc
= eliminate_regs (secondary_memlocs
[(int) mode
], VOIDmode
, NULL_RTX
);
644 mem_valid
= strict_memory_address_p (mode
, XEXP (loc
, 0));
646 if (! mem_valid
&& loc
== secondary_memlocs
[(int) mode
])
647 loc
= copy_rtx (loc
);
649 /* The only time the call below will do anything is if the stack
650 offset is too large. In that case IND_LEVELS doesn't matter, so we
651 can just pass a zero. Adjust the type to be the address of the
652 corresponding object. If the address was valid, save the eliminated
653 address. If it wasn't valid, we need to make a reload each time, so
658 type
= (type
== RELOAD_FOR_INPUT
? RELOAD_FOR_INPUT_ADDRESS
659 : type
== RELOAD_FOR_OUTPUT
? RELOAD_FOR_OUTPUT_ADDRESS
662 find_reloads_address (mode
, NULL_PTR
, XEXP (loc
, 0), &XEXP (loc
, 0),
666 secondary_memlocs_elim
[(int) mode
][opnum
] = loc
;
670 /* Clear any secondary memory locations we've made. */
673 clear_secondary_mem ()
675 bzero ((char *) secondary_memlocs
, sizeof secondary_memlocs
);
677 #endif /* SECONDARY_MEMORY_NEEDED */
679 /* Record one reload that needs to be performed.
680 IN is an rtx saying where the data are to be found before this instruction.
681 OUT says where they must be stored after the instruction.
682 (IN is zero for data not read, and OUT is zero for data not written.)
683 INLOC and OUTLOC point to the places in the instructions where
684 IN and OUT were found.
685 If IN and OUT are both non-zero, it means the same register must be used
686 to reload both IN and OUT.
688 CLASS is a register class required for the reloaded data.
689 INMODE is the machine mode that the instruction requires
690 for the reg that replaces IN and OUTMODE is likewise for OUT.
692 If IN is zero, then OUT's location and mode should be passed as
695 STRICT_LOW is the 1 if there is a containing STRICT_LOW_PART rtx.
697 OPTIONAL nonzero means this reload does not need to be performed:
698 it can be discarded if that is more convenient.
700 OPNUM and TYPE say what the purpose of this reload is.
702 The return value is the reload-number for this reload.
704 If both IN and OUT are nonzero, in some rare cases we might
705 want to make two separate reloads. (Actually we never do this now.)
706 Therefore, the reload-number for OUT is stored in
707 output_reloadnum when we return; the return value applies to IN.
708 Usually (presently always), when IN and OUT are nonzero,
709 the two reload-numbers are equal, but the caller should be careful to
713 push_reload (in
, out
, inloc
, outloc
, class,
714 inmode
, outmode
, strict_low
, optional
, opnum
, type
)
715 register rtx in
, out
;
717 enum reg_class
class;
718 enum machine_mode inmode
, outmode
;
722 enum reload_type type
;
726 rtx
*in_subreg_loc
= 0, *out_subreg_loc
= 0;
727 int secondary_in_reload
= -1, secondary_out_reload
= -1;
728 enum insn_code secondary_in_icode
= CODE_FOR_nothing
;
729 enum insn_code secondary_out_icode
= CODE_FOR_nothing
;
731 /* INMODE and/or OUTMODE could be VOIDmode if no mode
732 has been specified for the operand. In that case,
733 use the operand's mode as the mode to reload. */
734 if (inmode
== VOIDmode
&& in
!= 0)
735 inmode
= GET_MODE (in
);
736 if (outmode
== VOIDmode
&& out
!= 0)
737 outmode
= GET_MODE (out
);
739 /* If IN is a pseudo register everywhere-equivalent to a constant, and
740 it is not in a hard register, reload straight from the constant,
741 since we want to get rid of such pseudo registers.
742 Often this is done earlier, but not always in find_reloads_address. */
743 if (in
!= 0 && GET_CODE (in
) == REG
)
745 register int regno
= REGNO (in
);
747 if (regno
>= FIRST_PSEUDO_REGISTER
&& reg_renumber
[regno
] < 0
748 && reg_equiv_constant
[regno
] != 0)
749 in
= reg_equiv_constant
[regno
];
752 /* Likewise for OUT. Of course, OUT will never be equivalent to
753 an actual constant, but it might be equivalent to a memory location
754 (in the case of a parameter). */
755 if (out
!= 0 && GET_CODE (out
) == REG
)
757 register int regno
= REGNO (out
);
759 if (regno
>= FIRST_PSEUDO_REGISTER
&& reg_renumber
[regno
] < 0
760 && reg_equiv_constant
[regno
] != 0)
761 out
= reg_equiv_constant
[regno
];
764 /* If we have a read-write operand with an address side-effect,
765 change either IN or OUT so the side-effect happens only once. */
766 if (in
!= 0 && out
!= 0 && GET_CODE (in
) == MEM
&& rtx_equal_p (in
, out
))
768 if (GET_CODE (XEXP (in
, 0)) == POST_INC
769 || GET_CODE (XEXP (in
, 0)) == POST_DEC
)
770 in
= gen_rtx (MEM
, GET_MODE (in
), XEXP (XEXP (in
, 0), 0));
771 if (GET_CODE (XEXP (in
, 0)) == PRE_INC
772 || GET_CODE (XEXP (in
, 0)) == PRE_DEC
)
773 out
= gen_rtx (MEM
, GET_MODE (out
), XEXP (XEXP (out
, 0), 0));
776 /* If we are reloading a (SUBREG constant ...), really reload just the
777 inside expression in its own mode. Similarly for (SUBREG (PLUS ...)).
778 If we have (SUBREG:M1 (MEM:M2 ...) ...) (or an inner REG that is still
779 a pseudo and hence will become a MEM) with M1 wider than M2 and the
780 register is a pseudo, also reload the inside expression.
781 For machines that extend byte loads, do this for any SUBREG of a pseudo
782 where both M1 and M2 are a word or smaller, M1 is wider than M2, and
783 M2 is an integral mode that gets extended when loaded.
784 Similar issue for (SUBREG:M1 (REG:M2 ...) ...) for a hard register R where
785 either M1 is not valid for R or M2 is wider than a word but we only
786 need one word to store an M2-sized quantity in R.
787 (However, if OUT is nonzero, we need to reload the reg *and*
788 the subreg, so do nothing here, and let following statement handle it.)
790 Note that the case of (SUBREG (CONST_INT...)...) is handled elsewhere;
791 we can't handle it here because CONST_INT does not indicate a mode.
793 Similarly, we must reload the inside expression if we have a
794 STRICT_LOW_PART (presumably, in == out in the cas).
796 Also reload the inner expression if it does not require a secondary
797 reload but the SUBREG does.
799 Finally, reload the inner expression if it is a register that is in
800 the class whose registers cannot be referenced in a different size
801 and M1 is not the same size as M2. */
803 if (in
!= 0 && GET_CODE (in
) == SUBREG
804 #ifdef CLASS_CANNOT_CHANGE_SIZE
805 && class != CLASS_CANNOT_CHANGE_SIZE
807 && (CONSTANT_P (SUBREG_REG (in
))
808 || GET_CODE (SUBREG_REG (in
)) == PLUS
810 || (((GET_CODE (SUBREG_REG (in
)) == REG
811 && REGNO (SUBREG_REG (in
)) >= FIRST_PSEUDO_REGISTER
)
812 || GET_CODE (SUBREG_REG (in
)) == MEM
)
813 && ((GET_MODE_SIZE (inmode
)
814 > GET_MODE_SIZE (GET_MODE (SUBREG_REG (in
))))
815 #ifdef LOAD_EXTEND_OP
816 || (GET_MODE_SIZE (inmode
) <= UNITS_PER_WORD
817 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (in
)))
819 && (GET_MODE_SIZE (inmode
)
820 > GET_MODE_SIZE (GET_MODE (SUBREG_REG (in
))))
821 && INTEGRAL_MODE_P (GET_MODE (SUBREG_REG (in
)))
822 && LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (in
))) != NIL
)
825 || (GET_CODE (SUBREG_REG (in
)) == REG
826 && REGNO (SUBREG_REG (in
)) < FIRST_PSEUDO_REGISTER
827 /* The case where out is nonzero
828 is handled differently in the following statement. */
829 && (out
== 0 || SUBREG_WORD (in
) == 0)
830 && ((GET_MODE_SIZE (inmode
) <= UNITS_PER_WORD
831 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (in
)))
833 && ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in
)))
835 != HARD_REGNO_NREGS (REGNO (SUBREG_REG (in
)),
836 GET_MODE (SUBREG_REG (in
)))))
837 || ! HARD_REGNO_MODE_OK ((REGNO (SUBREG_REG (in
))
840 #ifdef SECONDARY_INPUT_RELOAD_CLASS
841 || (SECONDARY_INPUT_RELOAD_CLASS (class, inmode
, in
) != NO_REGS
842 && (SECONDARY_INPUT_RELOAD_CLASS (class,
843 GET_MODE (SUBREG_REG (in
)),
847 #ifdef CLASS_CANNOT_CHANGE_SIZE
848 || (GET_CODE (SUBREG_REG (in
)) == REG
849 && REGNO (SUBREG_REG (in
)) < FIRST_PSEUDO_REGISTER
850 && (TEST_HARD_REG_BIT
851 (reg_class_contents
[(int) CLASS_CANNOT_CHANGE_SIZE
],
852 REGNO (SUBREG_REG (in
))))
853 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (in
)))
854 != GET_MODE_SIZE (inmode
)))
858 in_subreg_loc
= inloc
;
859 inloc
= &SUBREG_REG (in
);
861 #ifndef LOAD_EXTEND_OP
862 if (GET_CODE (in
) == MEM
)
863 /* This is supposed to happen only for paradoxical subregs made by
864 combine.c. (SUBREG (MEM)) isn't supposed to occur other ways. */
865 if (GET_MODE_SIZE (GET_MODE (in
)) > GET_MODE_SIZE (inmode
))
868 inmode
= GET_MODE (in
);
871 /* Similar issue for (SUBREG:M1 (REG:M2 ...) ...) for a hard register R where
872 either M1 is not valid for R or M2 is wider than a word but we only
873 need one word to store an M2-sized quantity in R.
875 However, we must reload the inner reg *as well as* the subreg in
878 if (in
!= 0 && GET_CODE (in
) == SUBREG
879 && GET_CODE (SUBREG_REG (in
)) == REG
880 && REGNO (SUBREG_REG (in
)) < FIRST_PSEUDO_REGISTER
881 && (! HARD_REGNO_MODE_OK (REGNO (SUBREG_REG (in
)), inmode
)
882 || (GET_MODE_SIZE (inmode
) <= UNITS_PER_WORD
883 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (in
)))
885 && ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in
)))
887 != HARD_REGNO_NREGS (REGNO (SUBREG_REG (in
)),
888 GET_MODE (SUBREG_REG (in
)))))))
890 push_reload (SUBREG_REG (in
), NULL_RTX
, &SUBREG_REG (in
), NULL_PTR
,
891 GENERAL_REGS
, VOIDmode
, VOIDmode
, 0, 0, opnum
, type
);
895 /* Similarly for paradoxical and problematical SUBREGs on the output.
896 Note that there is no reason we need worry about the previous value
897 of SUBREG_REG (out); even if wider than out,
898 storing in a subreg is entitled to clobber it all
899 (except in the case of STRICT_LOW_PART,
900 and in that case the constraint should label it input-output.) */
901 if (out
!= 0 && GET_CODE (out
) == SUBREG
902 #ifdef CLASS_CANNOT_CHANGE_SIZE
903 && class != CLASS_CANNOT_CHANGE_SIZE
905 && (CONSTANT_P (SUBREG_REG (out
))
907 || (((GET_CODE (SUBREG_REG (out
)) == REG
908 && REGNO (SUBREG_REG (out
)) >= FIRST_PSEUDO_REGISTER
)
909 || GET_CODE (SUBREG_REG (out
)) == MEM
)
910 && ((GET_MODE_SIZE (outmode
)
911 > GET_MODE_SIZE (GET_MODE (SUBREG_REG (out
))))))
912 || (GET_CODE (SUBREG_REG (out
)) == REG
913 && REGNO (SUBREG_REG (out
)) < FIRST_PSEUDO_REGISTER
914 && ((GET_MODE_SIZE (outmode
) <= UNITS_PER_WORD
915 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (out
)))
917 && ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (out
)))
919 != HARD_REGNO_NREGS (REGNO (SUBREG_REG (out
)),
920 GET_MODE (SUBREG_REG (out
)))))
921 || ! HARD_REGNO_MODE_OK ((REGNO (SUBREG_REG (out
))
922 + SUBREG_WORD (out
)),
924 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
925 || (SECONDARY_OUTPUT_RELOAD_CLASS (class, outmode
, out
) != NO_REGS
926 && (SECONDARY_OUTPUT_RELOAD_CLASS (class,
927 GET_MODE (SUBREG_REG (out
)),
931 #ifdef CLASS_CANNOT_CHANGE_SIZE
932 || (GET_CODE (SUBREG_REG (out
)) == REG
933 && REGNO (SUBREG_REG (out
)) < FIRST_PSEUDO_REGISTER
934 && (TEST_HARD_REG_BIT
935 (reg_class_contents
[(int) CLASS_CANNOT_CHANGE_SIZE
],
936 REGNO (SUBREG_REG (out
))))
937 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (out
)))
938 != GET_MODE_SIZE (outmode
)))
942 out_subreg_loc
= outloc
;
943 outloc
= &SUBREG_REG (out
);
945 #ifndef LOAD_EXTEND_OP
946 if (GET_CODE (out
) == MEM
947 && GET_MODE_SIZE (GET_MODE (out
)) > GET_MODE_SIZE (outmode
))
950 outmode
= GET_MODE (out
);
953 /* If IN appears in OUT, we can't share any input-only reload for IN. */
954 if (in
!= 0 && out
!= 0 && GET_CODE (out
) == MEM
955 && (GET_CODE (in
) == REG
|| GET_CODE (in
) == MEM
)
956 && reg_overlap_mentioned_for_reload_p (in
, XEXP (out
, 0)))
959 /* If IN is a SUBREG of a hard register, make a new REG. This
960 simplifies some of the cases below. */
962 if (in
!= 0 && GET_CODE (in
) == SUBREG
&& GET_CODE (SUBREG_REG (in
)) == REG
963 && REGNO (SUBREG_REG (in
)) < FIRST_PSEUDO_REGISTER
)
964 in
= gen_rtx (REG
, GET_MODE (in
),
965 REGNO (SUBREG_REG (in
)) + SUBREG_WORD (in
));
967 /* Similarly for OUT. */
968 if (out
!= 0 && GET_CODE (out
) == SUBREG
969 && GET_CODE (SUBREG_REG (out
)) == REG
970 && REGNO (SUBREG_REG (out
)) < FIRST_PSEUDO_REGISTER
)
971 out
= gen_rtx (REG
, GET_MODE (out
),
972 REGNO (SUBREG_REG (out
)) + SUBREG_WORD (out
));
974 /* Narrow down the class of register wanted if that is
975 desirable on this machine for efficiency. */
977 class = PREFERRED_RELOAD_CLASS (in
, class);
979 /* Output reloads may need analogous treatment, different in detail. */
980 #ifdef PREFERRED_OUTPUT_RELOAD_CLASS
982 class = PREFERRED_OUTPUT_RELOAD_CLASS (out
, class);
985 /* Make sure we use a class that can handle the actual pseudo
986 inside any subreg. For example, on the 386, QImode regs
987 can appear within SImode subregs. Although GENERAL_REGS
988 can handle SImode, QImode needs a smaller class. */
989 #ifdef LIMIT_RELOAD_CLASS
991 class = LIMIT_RELOAD_CLASS (inmode
, class);
992 else if (in
!= 0 && GET_CODE (in
) == SUBREG
)
993 class = LIMIT_RELOAD_CLASS (GET_MODE (SUBREG_REG (in
)), class);
996 class = LIMIT_RELOAD_CLASS (outmode
, class);
997 if (out
!= 0 && GET_CODE (out
) == SUBREG
)
998 class = LIMIT_RELOAD_CLASS (GET_MODE (SUBREG_REG (out
)), class);
1001 /* Verify that this class is at least possible for the mode that
1003 if (this_insn_is_asm
)
1005 enum machine_mode mode
;
1006 if (GET_MODE_SIZE (inmode
) > GET_MODE_SIZE (outmode
))
1010 if (mode
== VOIDmode
)
1012 error_for_asm (this_insn
, "cannot reload integer constant operand in `asm'");
1017 outmode
= word_mode
;
1019 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
1020 if (HARD_REGNO_MODE_OK (i
, mode
)
1021 && TEST_HARD_REG_BIT (reg_class_contents
[(int) class], i
))
1023 int nregs
= HARD_REGNO_NREGS (i
, mode
);
1026 for (j
= 1; j
< nregs
; j
++)
1027 if (! TEST_HARD_REG_BIT (reg_class_contents
[(int) class], i
+ j
))
1032 if (i
== FIRST_PSEUDO_REGISTER
)
1034 error_for_asm (this_insn
, "impossible register constraint in `asm'");
1039 if (class == NO_REGS
)
1042 /* We can use an existing reload if the class is right
1043 and at least one of IN and OUT is a match
1044 and the other is at worst neutral.
1045 (A zero compared against anything is neutral.)
1047 If SMALL_REGISTER_CLASSES, don't use existing reloads unless they are
1048 for the same thing since that can cause us to need more reload registers
1049 than we otherwise would. */
1051 for (i
= 0; i
< n_reloads
; i
++)
1052 if ((reg_class_subset_p (class, reload_reg_class
[i
])
1053 || reg_class_subset_p (reload_reg_class
[i
], class))
1054 /* If the existing reload has a register, it must fit our class. */
1055 && (reload_reg_rtx
[i
] == 0
1056 || TEST_HARD_REG_BIT (reg_class_contents
[(int) class],
1057 true_regnum (reload_reg_rtx
[i
])))
1058 && ((in
!= 0 && MATCHES (reload_in
[i
], in
) && ! dont_share
1059 && (out
== 0 || reload_out
[i
] == 0 || MATCHES (reload_out
[i
], out
)))
1061 (out
!= 0 && MATCHES (reload_out
[i
], out
)
1062 && (in
== 0 || reload_in
[i
] == 0 || MATCHES (reload_in
[i
], in
))))
1063 && (reg_class_size
[(int) class] == 1
1064 #ifdef SMALL_REGISTER_CLASSES
1068 && MERGABLE_RELOADS (type
, reload_when_needed
[i
],
1069 opnum
, reload_opnum
[i
]))
1072 /* Reloading a plain reg for input can match a reload to postincrement
1073 that reg, since the postincrement's value is the right value.
1074 Likewise, it can match a preincrement reload, since we regard
1075 the preincrementation as happening before any ref in this insn
1076 to that register. */
1078 for (i
= 0; i
< n_reloads
; i
++)
1079 if ((reg_class_subset_p (class, reload_reg_class
[i
])
1080 || reg_class_subset_p (reload_reg_class
[i
], class))
1081 /* If the existing reload has a register, it must fit our class. */
1082 && (reload_reg_rtx
[i
] == 0
1083 || TEST_HARD_REG_BIT (reg_class_contents
[(int) class],
1084 true_regnum (reload_reg_rtx
[i
])))
1085 && out
== 0 && reload_out
[i
] == 0 && reload_in
[i
] != 0
1086 && ((GET_CODE (in
) == REG
1087 && (GET_CODE (reload_in
[i
]) == POST_INC
1088 || GET_CODE (reload_in
[i
]) == POST_DEC
1089 || GET_CODE (reload_in
[i
]) == PRE_INC
1090 || GET_CODE (reload_in
[i
]) == PRE_DEC
)
1091 && MATCHES (XEXP (reload_in
[i
], 0), in
))
1093 (GET_CODE (reload_in
[i
]) == REG
1094 && (GET_CODE (in
) == POST_INC
1095 || GET_CODE (in
) == POST_DEC
1096 || GET_CODE (in
) == PRE_INC
1097 || GET_CODE (in
) == PRE_DEC
)
1098 && MATCHES (XEXP (in
, 0), reload_in
[i
])))
1099 && (reg_class_size
[(int) class] == 1
1100 #ifdef SMALL_REGISTER_CLASSES
1104 && MERGABLE_RELOADS (type
, reload_when_needed
[i
],
1105 opnum
, reload_opnum
[i
]))
1107 /* Make sure reload_in ultimately has the increment,
1108 not the plain register. */
1109 if (GET_CODE (in
) == REG
)
1116 /* See if we need a secondary reload register to move between CLASS
1117 and IN or CLASS and OUT. Get the icode and push any required reloads
1118 needed for each of them if so. */
1120 #ifdef SECONDARY_INPUT_RELOAD_CLASS
1123 = push_secondary_reload (1, in
, opnum
, optional
, class, inmode
, type
,
1124 &secondary_in_icode
);
1127 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
1128 if (out
!= 0 && GET_CODE (out
) != SCRATCH
)
1129 secondary_out_reload
1130 = push_secondary_reload (0, out
, opnum
, optional
, class, outmode
,
1131 type
, &secondary_out_icode
);
1134 /* We found no existing reload suitable for re-use.
1135 So add an additional reload. */
1139 reload_out
[i
] = out
;
1140 reload_reg_class
[i
] = class;
1141 reload_inmode
[i
] = inmode
;
1142 reload_outmode
[i
] = outmode
;
1143 reload_reg_rtx
[i
] = 0;
1144 reload_optional
[i
] = optional
;
1146 reload_nocombine
[i
] = 0;
1147 reload_in_reg
[i
] = inloc
? *inloc
: 0;
1148 reload_opnum
[i
] = opnum
;
1149 reload_when_needed
[i
] = type
;
1150 reload_secondary_in_reload
[i
] = secondary_in_reload
;
1151 reload_secondary_out_reload
[i
] = secondary_out_reload
;
1152 reload_secondary_in_icode
[i
] = secondary_in_icode
;
1153 reload_secondary_out_icode
[i
] = secondary_out_icode
;
1154 reload_secondary_p
[i
] = 0;
1158 #ifdef SECONDARY_MEMORY_NEEDED
1159 /* If a memory location is needed for the copy, make one. */
1160 if (in
!= 0 && GET_CODE (in
) == REG
1161 && REGNO (in
) < FIRST_PSEUDO_REGISTER
1162 && SECONDARY_MEMORY_NEEDED (REGNO_REG_CLASS (REGNO (in
)),
1164 get_secondary_mem (in
, inmode
, opnum
, type
);
1166 if (out
!= 0 && GET_CODE (out
) == REG
1167 && REGNO (out
) < FIRST_PSEUDO_REGISTER
1168 && SECONDARY_MEMORY_NEEDED (class, REGNO_REG_CLASS (REGNO (out
)),
1170 get_secondary_mem (out
, outmode
, opnum
, type
);
1175 /* We are reusing an existing reload,
1176 but we may have additional information for it.
1177 For example, we may now have both IN and OUT
1178 while the old one may have just one of them. */
1180 if (inmode
!= VOIDmode
)
1181 reload_inmode
[i
] = inmode
;
1182 if (outmode
!= VOIDmode
)
1183 reload_outmode
[i
] = outmode
;
1187 reload_out
[i
] = out
;
1188 if (reg_class_subset_p (class, reload_reg_class
[i
]))
1189 reload_reg_class
[i
] = class;
1190 reload_optional
[i
] &= optional
;
1191 if (MERGE_TO_OTHER (type
, reload_when_needed
[i
],
1192 opnum
, reload_opnum
[i
]))
1193 reload_when_needed
[i
] = RELOAD_OTHER
;
1194 reload_opnum
[i
] = MIN (reload_opnum
[i
], opnum
);
1197 /* If the ostensible rtx being reload differs from the rtx found
1198 in the location to substitute, this reload is not safe to combine
1199 because we cannot reliably tell whether it appears in the insn. */
1201 if (in
!= 0 && in
!= *inloc
)
1202 reload_nocombine
[i
] = 1;
1205 /* This was replaced by changes in find_reloads_address_1 and the new
1206 function inc_for_reload, which go with a new meaning of reload_inc. */
1208 /* If this is an IN/OUT reload in an insn that sets the CC,
1209 it must be for an autoincrement. It doesn't work to store
1210 the incremented value after the insn because that would clobber the CC.
1211 So we must do the increment of the value reloaded from,
1212 increment it, store it back, then decrement again. */
1213 if (out
!= 0 && sets_cc0_p (PATTERN (this_insn
)))
1217 reload_inc
[i
] = find_inc_amount (PATTERN (this_insn
), in
);
1218 /* If we did not find a nonzero amount-to-increment-by,
1219 that contradicts the belief that IN is being incremented
1220 in an address in this insn. */
1221 if (reload_inc
[i
] == 0)
1226 /* If we will replace IN and OUT with the reload-reg,
1227 record where they are located so that substitution need
1228 not do a tree walk. */
1230 if (replace_reloads
)
1234 register struct replacement
*r
= &replacements
[n_replacements
++];
1236 r
->subreg_loc
= in_subreg_loc
;
1240 if (outloc
!= 0 && outloc
!= inloc
)
1242 register struct replacement
*r
= &replacements
[n_replacements
++];
1245 r
->subreg_loc
= out_subreg_loc
;
1250 /* If this reload is just being introduced and it has both
1251 an incoming quantity and an outgoing quantity that are
1252 supposed to be made to match, see if either one of the two
1253 can serve as the place to reload into.
1255 If one of them is acceptable, set reload_reg_rtx[i]
1258 if (in
!= 0 && out
!= 0 && in
!= out
&& reload_reg_rtx
[i
] == 0)
1260 reload_reg_rtx
[i
] = find_dummy_reload (in
, out
, inloc
, outloc
,
1262 reload_reg_class
[i
], i
);
1264 /* If the outgoing register already contains the same value
1265 as the incoming one, we can dispense with loading it.
1266 The easiest way to tell the caller that is to give a phony
1267 value for the incoming operand (same as outgoing one). */
1268 if (reload_reg_rtx
[i
] == out
1269 && (GET_CODE (in
) == REG
|| CONSTANT_P (in
))
1270 && 0 != find_equiv_reg (in
, this_insn
, 0, REGNO (out
),
1271 static_reload_reg_p
, i
, inmode
))
1275 /* If this is an input reload and the operand contains a register that
1276 dies in this insn and is used nowhere else, see if it is the right class
1277 to be used for this reload. Use it if so. (This occurs most commonly
1278 in the case of paradoxical SUBREGs and in-out reloads). We cannot do
1279 this if it is also an output reload that mentions the register unless
1280 the output is a SUBREG that clobbers an entire register.
1282 Note that the operand might be one of the spill regs, if it is a
1283 pseudo reg and we are in a block where spilling has not taken place.
1284 But if there is no spilling in this block, that is OK.
1285 An explicitly used hard reg cannot be a spill reg. */
1287 if (reload_reg_rtx
[i
] == 0 && in
!= 0)
1292 for (note
= REG_NOTES (this_insn
); note
; note
= XEXP (note
, 1))
1293 if (REG_NOTE_KIND (note
) == REG_DEAD
1294 && GET_CODE (XEXP (note
, 0)) == REG
1295 && (regno
= REGNO (XEXP (note
, 0))) < FIRST_PSEUDO_REGISTER
1296 && reg_mentioned_p (XEXP (note
, 0), in
)
1297 && ! refers_to_regno_for_reload_p (regno
,
1299 + HARD_REGNO_NREGS (regno
,
1301 PATTERN (this_insn
), inloc
)
1302 /* If this is also an output reload, IN cannot be used as
1303 the reload register if it is set in this insn unless IN
1305 && (out
== 0 || in
== out
1306 || ! hard_reg_set_here_p (regno
,
1308 + HARD_REGNO_NREGS (regno
,
1310 PATTERN (this_insn
)))
1311 /* ??? Why is this code so different from the previous?
1312 Is there any simple coherent way to describe the two together?
1313 What's going on here. */
1315 || (GET_CODE (in
) == SUBREG
1316 && (((GET_MODE_SIZE (GET_MODE (in
)) + (UNITS_PER_WORD
- 1))
1318 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in
)))
1319 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
))))
1320 /* Make sure the operand fits in the reg that dies. */
1321 && GET_MODE_SIZE (inmode
) <= GET_MODE_SIZE (GET_MODE (XEXP (note
, 0)))
1322 && HARD_REGNO_MODE_OK (regno
, inmode
)
1323 && GET_MODE_SIZE (outmode
) <= GET_MODE_SIZE (GET_MODE (XEXP (note
, 0)))
1324 && HARD_REGNO_MODE_OK (regno
, outmode
)
1325 && TEST_HARD_REG_BIT (reg_class_contents
[(int) class], regno
)
1326 && !fixed_regs
[regno
])
1328 reload_reg_rtx
[i
] = gen_rtx (REG
, inmode
, regno
);
1334 output_reloadnum
= i
;
1339 /* Record an additional place we must replace a value
1340 for which we have already recorded a reload.
1341 RELOADNUM is the value returned by push_reload
1342 when the reload was recorded.
1343 This is used in insn patterns that use match_dup. */
1346 push_replacement (loc
, reloadnum
, mode
)
1349 enum machine_mode mode
;
1351 if (replace_reloads
)
1353 register struct replacement
*r
= &replacements
[n_replacements
++];
1354 r
->what
= reloadnum
;
1361 /* Transfer all replacements that used to be in reload FROM to be in
1365 transfer_replacements (to
, from
)
1370 for (i
= 0; i
< n_replacements
; i
++)
1371 if (replacements
[i
].what
== from
)
1372 replacements
[i
].what
= to
;
1375 /* If there is only one output reload, and it is not for an earlyclobber
1376 operand, try to combine it with a (logically unrelated) input reload
1377 to reduce the number of reload registers needed.
1379 This is safe if the input reload does not appear in
1380 the value being output-reloaded, because this implies
1381 it is not needed any more once the original insn completes.
1383 If that doesn't work, see we can use any of the registers that
1384 die in this insn as a reload register. We can if it is of the right
1385 class and does not appear in the value being output-reloaded. */
1391 int output_reload
= -1;
1392 int secondary_out
= -1;
1395 /* Find the output reload; return unless there is exactly one
1396 and that one is mandatory. */
1398 for (i
= 0; i
< n_reloads
; i
++)
1399 if (reload_out
[i
] != 0)
1401 if (output_reload
>= 0)
1406 if (output_reload
< 0 || reload_optional
[output_reload
])
1409 /* An input-output reload isn't combinable. */
1411 if (reload_in
[output_reload
] != 0)
1414 /* If this reload is for an earlyclobber operand, we can't do anything. */
1415 if (earlyclobber_operand_p (reload_out
[output_reload
]))
1418 /* Check each input reload; can we combine it? */
1420 for (i
= 0; i
< n_reloads
; i
++)
1421 if (reload_in
[i
] && ! reload_optional
[i
] && ! reload_nocombine
[i
]
1422 /* Life span of this reload must not extend past main insn. */
1423 && reload_when_needed
[i
] != RELOAD_FOR_OUTPUT_ADDRESS
1424 && reload_when_needed
[i
] != RELOAD_OTHER
1425 && (CLASS_MAX_NREGS (reload_reg_class
[i
], reload_inmode
[i
])
1426 == CLASS_MAX_NREGS (reload_reg_class
[output_reload
],
1427 reload_outmode
[output_reload
]))
1428 && reload_inc
[i
] == 0
1429 && reload_reg_rtx
[i
] == 0
1430 #ifdef SECONDARY_MEMORY_NEEDED
1431 /* Don't combine two reloads with different secondary
1432 memory locations. */
1433 && (secondary_memlocs_elim
[(int) reload_outmode
[output_reload
]][reload_opnum
[i
]] == 0
1434 || secondary_memlocs_elim
[(int) reload_outmode
[output_reload
]][reload_opnum
[output_reload
]] == 0
1435 || rtx_equal_p (secondary_memlocs_elim
[(int) reload_outmode
[output_reload
]][reload_opnum
[i
]],
1436 secondary_memlocs_elim
[(int) reload_outmode
[output_reload
]][reload_opnum
[output_reload
]]))
1438 #ifdef SMALL_REGISTER_CLASSES
1439 && reload_reg_class
[i
] == reload_reg_class
[output_reload
]
1441 && (reg_class_subset_p (reload_reg_class
[i
],
1442 reload_reg_class
[output_reload
])
1443 || reg_class_subset_p (reload_reg_class
[output_reload
],
1444 reload_reg_class
[i
]))
1446 && (MATCHES (reload_in
[i
], reload_out
[output_reload
])
1447 /* Args reversed because the first arg seems to be
1448 the one that we imagine being modified
1449 while the second is the one that might be affected. */
1450 || (! reg_overlap_mentioned_for_reload_p (reload_out
[output_reload
],
1452 /* However, if the input is a register that appears inside
1453 the output, then we also can't share.
1454 Imagine (set (mem (reg 69)) (plus (reg 69) ...)).
1455 If the same reload reg is used for both reg 69 and the
1456 result to be stored in memory, then that result
1457 will clobber the address of the memory ref. */
1458 && ! (GET_CODE (reload_in
[i
]) == REG
1459 && reg_overlap_mentioned_for_reload_p (reload_in
[i
],
1460 reload_out
[output_reload
]))))
1461 && (reg_class_size
[(int) reload_reg_class
[i
]]
1462 #ifdef SMALL_REGISTER_CLASSES
1466 /* We will allow making things slightly worse by combining an
1467 input and an output, but no worse than that. */
1468 && (reload_when_needed
[i
] == RELOAD_FOR_INPUT
1469 || reload_when_needed
[i
] == RELOAD_FOR_OUTPUT
))
1473 /* We have found a reload to combine with! */
1474 reload_out
[i
] = reload_out
[output_reload
];
1475 reload_outmode
[i
] = reload_outmode
[output_reload
];
1476 /* Mark the old output reload as inoperative. */
1477 reload_out
[output_reload
] = 0;
1478 /* The combined reload is needed for the entire insn. */
1479 reload_when_needed
[i
] = RELOAD_OTHER
;
1480 /* If the output reload had a secondary reload, copy it. */
1481 if (reload_secondary_out_reload
[output_reload
] != -1)
1483 reload_secondary_out_reload
[i
]
1484 = reload_secondary_out_reload
[output_reload
];
1485 reload_secondary_out_icode
[i
]
1486 = reload_secondary_out_icode
[output_reload
];
1489 #ifdef SECONDARY_MEMORY_NEEDED
1490 /* Copy any secondary MEM. */
1491 if (secondary_memlocs_elim
[(int) reload_outmode
[output_reload
]][reload_opnum
[output_reload
]] != 0)
1492 secondary_memlocs_elim
[(int) reload_outmode
[output_reload
]][reload_opnum
[i
]]
1493 = secondary_memlocs_elim
[(int) reload_outmode
[output_reload
]][reload_opnum
[output_reload
]];
1495 /* If required, minimize the register class. */
1496 if (reg_class_subset_p (reload_reg_class
[output_reload
],
1497 reload_reg_class
[i
]))
1498 reload_reg_class
[i
] = reload_reg_class
[output_reload
];
1500 /* Transfer all replacements from the old reload to the combined. */
1501 for (j
= 0; j
< n_replacements
; j
++)
1502 if (replacements
[j
].what
== output_reload
)
1503 replacements
[j
].what
= i
;
1508 /* If this insn has only one operand that is modified or written (assumed
1509 to be the first), it must be the one corresponding to this reload. It
1510 is safe to use anything that dies in this insn for that output provided
1511 that it does not occur in the output (we already know it isn't an
1512 earlyclobber. If this is an asm insn, give up. */
1514 if (INSN_CODE (this_insn
) == -1)
1517 for (i
= 1; i
< insn_n_operands
[INSN_CODE (this_insn
)]; i
++)
1518 if (insn_operand_constraint
[INSN_CODE (this_insn
)][i
][0] == '='
1519 || insn_operand_constraint
[INSN_CODE (this_insn
)][i
][0] == '+')
1522 /* See if some hard register that dies in this insn and is not used in
1523 the output is the right class. Only works if the register we pick
1524 up can fully hold our output reload. */
1525 for (note
= REG_NOTES (this_insn
); note
; note
= XEXP (note
, 1))
1526 if (REG_NOTE_KIND (note
) == REG_DEAD
1527 && GET_CODE (XEXP (note
, 0)) == REG
1528 && ! reg_overlap_mentioned_for_reload_p (XEXP (note
, 0),
1529 reload_out
[output_reload
])
1530 && REGNO (XEXP (note
, 0)) < FIRST_PSEUDO_REGISTER
1531 && HARD_REGNO_MODE_OK (REGNO (XEXP (note
, 0)), reload_outmode
[output_reload
])
1532 && TEST_HARD_REG_BIT (reg_class_contents
[(int) reload_reg_class
[output_reload
]],
1533 REGNO (XEXP (note
, 0)))
1534 && (HARD_REGNO_NREGS (REGNO (XEXP (note
, 0)), reload_outmode
[output_reload
])
1535 <= HARD_REGNO_NREGS (REGNO (XEXP (note
, 0)), GET_MODE (XEXP (note
, 0))))
1536 /* Ensure that a secondary or tertiary reload for this output
1537 won't want this register. */
1538 && ((secondary_out
= reload_secondary_out_reload
[output_reload
]) == -1
1539 || (! (TEST_HARD_REG_BIT
1540 (reg_class_contents
[(int) reload_reg_class
[secondary_out
]],
1541 REGNO (XEXP (note
, 0))))
1542 && ((secondary_out
= reload_secondary_out_reload
[secondary_out
]) == -1
1543 || ! (TEST_HARD_REG_BIT
1544 (reg_class_contents
[(int) reload_reg_class
[secondary_out
]],
1545 REGNO (XEXP (note
, 0)))))))
1546 && ! fixed_regs
[REGNO (XEXP (note
, 0))])
1548 reload_reg_rtx
[output_reload
] = gen_rtx (REG
,
1549 reload_outmode
[output_reload
],
1550 REGNO (XEXP (note
, 0)));
1555 /* Try to find a reload register for an in-out reload (expressions IN and OUT).
1556 See if one of IN and OUT is a register that may be used;
1557 this is desirable since a spill-register won't be needed.
1558 If so, return the register rtx that proves acceptable.
1560 INLOC and OUTLOC are locations where IN and OUT appear in the insn.
1561 CLASS is the register class required for the reload.
1563 If FOR_REAL is >= 0, it is the number of the reload,
1564 and in some cases when it can be discovered that OUT doesn't need
1565 to be computed, clear out reload_out[FOR_REAL].
1567 If FOR_REAL is -1, this should not be done, because this call
1568 is just to see if a register can be found, not to find and install it. */
1571 find_dummy_reload (real_in
, real_out
, inloc
, outloc
,
1572 inmode
, outmode
, class, for_real
)
1573 rtx real_in
, real_out
;
1574 rtx
*inloc
, *outloc
;
1575 enum machine_mode inmode
, outmode
;
1576 enum reg_class
class;
1585 /* If operands exceed a word, we can't use either of them
1586 unless they have the same size. */
1587 if (GET_MODE_SIZE (outmode
) != GET_MODE_SIZE (inmode
)
1588 && (GET_MODE_SIZE (outmode
) > UNITS_PER_WORD
1589 || GET_MODE_SIZE (inmode
) > UNITS_PER_WORD
))
1592 /* Find the inside of any subregs. */
1593 while (GET_CODE (out
) == SUBREG
)
1595 out_offset
= SUBREG_WORD (out
);
1596 out
= SUBREG_REG (out
);
1598 while (GET_CODE (in
) == SUBREG
)
1600 in_offset
= SUBREG_WORD (in
);
1601 in
= SUBREG_REG (in
);
1604 /* Narrow down the reg class, the same way push_reload will;
1605 otherwise we might find a dummy now, but push_reload won't. */
1606 class = PREFERRED_RELOAD_CLASS (in
, class);
1608 /* See if OUT will do. */
1609 if (GET_CODE (out
) == REG
1610 && REGNO (out
) < FIRST_PSEUDO_REGISTER
)
1612 register int regno
= REGNO (out
) + out_offset
;
1613 int nwords
= HARD_REGNO_NREGS (regno
, outmode
);
1616 /* When we consider whether the insn uses OUT,
1617 ignore references within IN. They don't prevent us
1618 from copying IN into OUT, because those refs would
1619 move into the insn that reloads IN.
1621 However, we only ignore IN in its role as this reload.
1622 If the insn uses IN elsewhere and it contains OUT,
1623 that counts. We can't be sure it's the "same" operand
1624 so it might not go through this reload. */
1626 *inloc
= const0_rtx
;
1628 if (regno
< FIRST_PSEUDO_REGISTER
1629 /* A fixed reg that can overlap other regs better not be used
1630 for reloading in any way. */
1631 #ifdef OVERLAPPING_REGNO_P
1632 && ! (fixed_regs
[regno
] && OVERLAPPING_REGNO_P (regno
))
1634 && ! refers_to_regno_for_reload_p (regno
, regno
+ nwords
,
1635 PATTERN (this_insn
), outloc
))
1638 for (i
= 0; i
< nwords
; i
++)
1639 if (! TEST_HARD_REG_BIT (reg_class_contents
[(int) class],
1645 if (GET_CODE (real_out
) == REG
)
1648 value
= gen_rtx (REG
, outmode
, regno
);
1655 /* Consider using IN if OUT was not acceptable
1656 or if OUT dies in this insn (like the quotient in a divmod insn).
1657 We can't use IN unless it is dies in this insn,
1658 which means we must know accurately which hard regs are live.
1659 Also, the result can't go in IN if IN is used within OUT. */
1660 if (hard_regs_live_known
1661 && GET_CODE (in
) == REG
1662 && REGNO (in
) < FIRST_PSEUDO_REGISTER
1664 || find_reg_note (this_insn
, REG_UNUSED
, real_out
))
1665 && find_reg_note (this_insn
, REG_DEAD
, real_in
)
1666 && !fixed_regs
[REGNO (in
)]
1667 && HARD_REGNO_MODE_OK (REGNO (in
),
1668 /* The only case where out and real_out might
1669 have different modes is where real_out
1670 is a subreg, and in that case, out
1672 (GET_MODE (out
) != VOIDmode
1673 ? GET_MODE (out
) : outmode
)))
1675 register int regno
= REGNO (in
) + in_offset
;
1676 int nwords
= HARD_REGNO_NREGS (regno
, inmode
);
1678 if (! refers_to_regno_for_reload_p (regno
, regno
+ nwords
, out
, NULL_PTR
)
1679 && ! hard_reg_set_here_p (regno
, regno
+ nwords
,
1680 PATTERN (this_insn
)))
1683 for (i
= 0; i
< nwords
; i
++)
1684 if (! TEST_HARD_REG_BIT (reg_class_contents
[(int) class],
1690 /* If we were going to use OUT as the reload reg
1691 and changed our mind, it means OUT is a dummy that
1692 dies here. So don't bother copying value to it. */
1693 if (for_real
>= 0 && value
== real_out
)
1694 reload_out
[for_real
] = 0;
1695 if (GET_CODE (real_in
) == REG
)
1698 value
= gen_rtx (REG
, inmode
, regno
);
1706 /* This page contains subroutines used mainly for determining
1707 whether the IN or an OUT of a reload can serve as the
1710 /* Return 1 if X is an operand of an insn that is being earlyclobbered. */
1713 earlyclobber_operand_p (x
)
1718 for (i
= 0; i
< n_earlyclobbers
; i
++)
1719 if (reload_earlyclobbers
[i
] == x
)
1725 /* Return 1 if expression X alters a hard reg in the range
1726 from BEG_REGNO (inclusive) to END_REGNO (exclusive),
1727 either explicitly or in the guise of a pseudo-reg allocated to REGNO.
1728 X should be the body of an instruction. */
1731 hard_reg_set_here_p (beg_regno
, end_regno
, x
)
1732 register int beg_regno
, end_regno
;
1735 if (GET_CODE (x
) == SET
|| GET_CODE (x
) == CLOBBER
)
1737 register rtx op0
= SET_DEST (x
);
1738 while (GET_CODE (op0
) == SUBREG
)
1739 op0
= SUBREG_REG (op0
);
1740 if (GET_CODE (op0
) == REG
)
1742 register int r
= REGNO (op0
);
1743 /* See if this reg overlaps range under consideration. */
1745 && r
+ HARD_REGNO_NREGS (r
, GET_MODE (op0
)) > beg_regno
)
1749 else if (GET_CODE (x
) == PARALLEL
)
1751 register int i
= XVECLEN (x
, 0) - 1;
1753 if (hard_reg_set_here_p (beg_regno
, end_regno
, XVECEXP (x
, 0, i
)))
1760 /* Return 1 if ADDR is a valid memory address for mode MODE,
1761 and check that each pseudo reg has the proper kind of
1765 strict_memory_address_p (mode
, addr
)
1766 enum machine_mode mode
;
1769 GO_IF_LEGITIMATE_ADDRESS (mode
, addr
, win
);
1776 /* Like rtx_equal_p except that it allows a REG and a SUBREG to match
1777 if they are the same hard reg, and has special hacks for
1778 autoincrement and autodecrement.
1779 This is specifically intended for find_reloads to use
1780 in determining whether two operands match.
1781 X is the operand whose number is the lower of the two.
1783 The value is 2 if Y contains a pre-increment that matches
1784 a non-incrementing address in X. */
1786 /* ??? To be completely correct, we should arrange to pass
1787 for X the output operand and for Y the input operand.
1788 For now, we assume that the output operand has the lower number
1789 because that is natural in (SET output (... input ...)). */
1792 operands_match_p (x
, y
)
1796 register RTX_CODE code
= GET_CODE (x
);
1802 if ((code
== REG
|| (code
== SUBREG
&& GET_CODE (SUBREG_REG (x
)) == REG
))
1803 && (GET_CODE (y
) == REG
|| (GET_CODE (y
) == SUBREG
1804 && GET_CODE (SUBREG_REG (y
)) == REG
)))
1810 i
= REGNO (SUBREG_REG (x
));
1811 if (i
>= FIRST_PSEUDO_REGISTER
)
1813 i
+= SUBREG_WORD (x
);
1818 if (GET_CODE (y
) == SUBREG
)
1820 j
= REGNO (SUBREG_REG (y
));
1821 if (j
>= FIRST_PSEUDO_REGISTER
)
1823 j
+= SUBREG_WORD (y
);
1828 /* On a WORDS_BIG_ENDIAN machine, point to the last register of a
1829 multiple hard register group, so that for example (reg:DI 0) and
1830 (reg:SI 1) will be considered the same register. */
1831 if (WORDS_BIG_ENDIAN
&& GET_MODE_SIZE (GET_MODE (x
)) > UNITS_PER_WORD
1832 && i
< FIRST_PSEUDO_REGISTER
)
1833 i
+= (GET_MODE_SIZE (GET_MODE (x
)) / UNITS_PER_WORD
) - 1;
1834 if (WORDS_BIG_ENDIAN
&& GET_MODE_SIZE (GET_MODE (y
)) > UNITS_PER_WORD
1835 && j
< FIRST_PSEUDO_REGISTER
)
1836 j
+= (GET_MODE_SIZE (GET_MODE (y
)) / UNITS_PER_WORD
) - 1;
1840 /* If two operands must match, because they are really a single
1841 operand of an assembler insn, then two postincrements are invalid
1842 because the assembler insn would increment only once.
1843 On the other hand, an postincrement matches ordinary indexing
1844 if the postincrement is the output operand. */
1845 if (code
== POST_DEC
|| code
== POST_INC
)
1846 return operands_match_p (XEXP (x
, 0), y
);
1847 /* Two preincrements are invalid
1848 because the assembler insn would increment only once.
1849 On the other hand, an preincrement matches ordinary indexing
1850 if the preincrement is the input operand.
1851 In this case, return 2, since some callers need to do special
1852 things when this happens. */
1853 if (GET_CODE (y
) == PRE_DEC
|| GET_CODE (y
) == PRE_INC
)
1854 return operands_match_p (x
, XEXP (y
, 0)) ? 2 : 0;
1858 /* Now we have disposed of all the cases
1859 in which different rtx codes can match. */
1860 if (code
!= GET_CODE (y
))
1862 if (code
== LABEL_REF
)
1863 return XEXP (x
, 0) == XEXP (y
, 0);
1864 if (code
== SYMBOL_REF
)
1865 return XSTR (x
, 0) == XSTR (y
, 0);
1867 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. */
1869 if (GET_MODE (x
) != GET_MODE (y
))
1872 /* Compare the elements. If any pair of corresponding elements
1873 fail to match, return 0 for the whole things. */
1876 fmt
= GET_RTX_FORMAT (code
);
1877 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1883 if (XWINT (x
, i
) != XWINT (y
, i
))
1888 if (XINT (x
, i
) != XINT (y
, i
))
1893 val
= operands_match_p (XEXP (x
, i
), XEXP (y
, i
));
1896 /* If any subexpression returns 2,
1897 we should return 2 if we are successful. */
1905 /* It is believed that rtx's at this level will never
1906 contain anything but integers and other rtx's,
1907 except for within LABEL_REFs and SYMBOL_REFs. */
1912 return 1 + success_2
;
1915 /* Return the number of times character C occurs in string S. */
1918 n_occurrences (c
, s
)
1928 /* Describe the range of registers or memory referenced by X.
1929 If X is a register, set REG_FLAG and put the first register
1930 number into START and the last plus one into END.
1931 If X is a memory reference, put a base address into BASE
1932 and a range of integer offsets into START and END.
1933 If X is pushing on the stack, we can assume it causes no trouble,
1934 so we set the SAFE field. */
1936 static struct decomposition
1940 struct decomposition val
;
1945 if (GET_CODE (x
) == MEM
)
1947 rtx base
, offset
= 0;
1948 rtx addr
= XEXP (x
, 0);
1950 if (GET_CODE (addr
) == PRE_DEC
|| GET_CODE (addr
) == PRE_INC
1951 || GET_CODE (addr
) == POST_DEC
|| GET_CODE (addr
) == POST_INC
)
1953 val
.base
= XEXP (addr
, 0);
1954 val
.start
= - GET_MODE_SIZE (GET_MODE (x
));
1955 val
.end
= GET_MODE_SIZE (GET_MODE (x
));
1956 val
.safe
= REGNO (val
.base
) == STACK_POINTER_REGNUM
;
1960 if (GET_CODE (addr
) == CONST
)
1962 addr
= XEXP (addr
, 0);
1965 if (GET_CODE (addr
) == PLUS
)
1967 if (CONSTANT_P (XEXP (addr
, 0)))
1969 base
= XEXP (addr
, 1);
1970 offset
= XEXP (addr
, 0);
1972 else if (CONSTANT_P (XEXP (addr
, 1)))
1974 base
= XEXP (addr
, 0);
1975 offset
= XEXP (addr
, 1);
1982 offset
= const0_rtx
;
1984 if (GET_CODE (offset
) == CONST
)
1985 offset
= XEXP (offset
, 0);
1986 if (GET_CODE (offset
) == PLUS
)
1988 if (GET_CODE (XEXP (offset
, 0)) == CONST_INT
)
1990 base
= gen_rtx (PLUS
, GET_MODE (base
), base
, XEXP (offset
, 1));
1991 offset
= XEXP (offset
, 0);
1993 else if (GET_CODE (XEXP (offset
, 1)) == CONST_INT
)
1995 base
= gen_rtx (PLUS
, GET_MODE (base
), base
, XEXP (offset
, 0));
1996 offset
= XEXP (offset
, 1);
2000 base
= gen_rtx (PLUS
, GET_MODE (base
), base
, offset
);
2001 offset
= const0_rtx
;
2004 else if (GET_CODE (offset
) != CONST_INT
)
2006 base
= gen_rtx (PLUS
, GET_MODE (base
), base
, offset
);
2007 offset
= const0_rtx
;
2010 if (all_const
&& GET_CODE (base
) == PLUS
)
2011 base
= gen_rtx (CONST
, GET_MODE (base
), base
);
2013 if (GET_CODE (offset
) != CONST_INT
)
2016 val
.start
= INTVAL (offset
);
2017 val
.end
= val
.start
+ GET_MODE_SIZE (GET_MODE (x
));
2021 else if (GET_CODE (x
) == REG
)
2024 val
.start
= true_regnum (x
);
2027 /* A pseudo with no hard reg. */
2028 val
.start
= REGNO (x
);
2029 val
.end
= val
.start
+ 1;
2033 val
.end
= val
.start
+ HARD_REGNO_NREGS (val
.start
, GET_MODE (x
));
2035 else if (GET_CODE (x
) == SUBREG
)
2037 if (GET_CODE (SUBREG_REG (x
)) != REG
)
2038 /* This could be more precise, but it's good enough. */
2039 return decompose (SUBREG_REG (x
));
2041 val
.start
= true_regnum (x
);
2043 return decompose (SUBREG_REG (x
));
2046 val
.end
= val
.start
+ HARD_REGNO_NREGS (val
.start
, GET_MODE (x
));
2048 else if (CONSTANT_P (x
)
2049 /* This hasn't been assigned yet, so it can't conflict yet. */
2050 || GET_CODE (x
) == SCRATCH
)
2057 /* Return 1 if altering Y will not modify the value of X.
2058 Y is also described by YDATA, which should be decompose (Y). */
2061 immune_p (x
, y
, ydata
)
2063 struct decomposition ydata
;
2065 struct decomposition xdata
;
2068 return !refers_to_regno_for_reload_p (ydata
.start
, ydata
.end
, x
, NULL_PTR
);
2072 if (GET_CODE (y
) != MEM
)
2074 /* If Y is memory and X is not, Y can't affect X. */
2075 if (GET_CODE (x
) != MEM
)
2078 xdata
= decompose (x
);
2080 if (! rtx_equal_p (xdata
.base
, ydata
.base
))
2082 /* If bases are distinct symbolic constants, there is no overlap. */
2083 if (CONSTANT_P (xdata
.base
) && CONSTANT_P (ydata
.base
))
2085 /* Constants and stack slots never overlap. */
2086 if (CONSTANT_P (xdata
.base
)
2087 && (ydata
.base
== frame_pointer_rtx
2088 || ydata
.base
== hard_frame_pointer_rtx
2089 || ydata
.base
== stack_pointer_rtx
))
2091 if (CONSTANT_P (ydata
.base
)
2092 && (xdata
.base
== frame_pointer_rtx
2093 || xdata
.base
== hard_frame_pointer_rtx
2094 || xdata
.base
== stack_pointer_rtx
))
2096 /* If either base is variable, we don't know anything. */
2101 return (xdata
.start
>= ydata
.end
|| ydata
.start
>= xdata
.end
);
2104 /* Similar, but calls decompose. */
2107 safe_from_earlyclobber (op
, clobber
)
2110 struct decomposition early_data
;
2112 early_data
= decompose (clobber
);
2113 return immune_p (op
, clobber
, early_data
);
2116 /* Main entry point of this file: search the body of INSN
2117 for values that need reloading and record them with push_reload.
2118 REPLACE nonzero means record also where the values occur
2119 so that subst_reloads can be used.
2121 IND_LEVELS says how many levels of indirection are supported by this
2122 machine; a value of zero means that a memory reference is not a valid
2125 LIVE_KNOWN says we have valid information about which hard
2126 regs are live at each point in the program; this is true when
2127 we are called from global_alloc but false when stupid register
2128 allocation has been done.
2130 RELOAD_REG_P if nonzero is a vector indexed by hard reg number
2131 which is nonnegative if the reg has been commandeered for reloading into.
2132 It is copied into STATIC_RELOAD_REG_P and referenced from there
2133 by various subroutines. */
2136 find_reloads (insn
, replace
, ind_levels
, live_known
, reload_reg_p
)
2138 int replace
, ind_levels
;
2140 short *reload_reg_p
;
2142 #ifdef REGISTER_CONSTRAINTS
2144 register int insn_code_number
;
2147 /* These are the constraints for the insn. We don't change them. */
2148 char *constraints1
[MAX_RECOG_OPERANDS
];
2149 /* These start out as the constraints for the insn
2150 and they are chewed up as we consider alternatives. */
2151 char *constraints
[MAX_RECOG_OPERANDS
];
2152 /* These are the preferred classes for an operand, or NO_REGS if it isn't
2154 enum reg_class preferred_class
[MAX_RECOG_OPERANDS
];
2155 char pref_or_nothing
[MAX_RECOG_OPERANDS
];
2156 /* Nonzero for a MEM operand whose entire address needs a reload. */
2157 int address_reloaded
[MAX_RECOG_OPERANDS
];
2158 /* Value of enum reload_type to use for operand. */
2159 enum reload_type operand_type
[MAX_RECOG_OPERANDS
];
2160 /* Value of enum reload_type to use within address of operand. */
2161 enum reload_type address_type
[MAX_RECOG_OPERANDS
];
2162 /* Save the usage of each operand. */
2163 enum reload_usage
{ RELOAD_READ
, RELOAD_READ_WRITE
, RELOAD_WRITE
} modified
[MAX_RECOG_OPERANDS
];
2164 int no_input_reloads
= 0, no_output_reloads
= 0;
2166 int this_alternative
[MAX_RECOG_OPERANDS
];
2167 char this_alternative_win
[MAX_RECOG_OPERANDS
];
2168 char this_alternative_offmemok
[MAX_RECOG_OPERANDS
];
2169 char this_alternative_earlyclobber
[MAX_RECOG_OPERANDS
];
2170 int this_alternative_matches
[MAX_RECOG_OPERANDS
];
2172 int goal_alternative
[MAX_RECOG_OPERANDS
];
2173 int this_alternative_number
;
2174 int goal_alternative_number
;
2175 int operand_reloadnum
[MAX_RECOG_OPERANDS
];
2176 int goal_alternative_matches
[MAX_RECOG_OPERANDS
];
2177 int goal_alternative_matched
[MAX_RECOG_OPERANDS
];
2178 char goal_alternative_win
[MAX_RECOG_OPERANDS
];
2179 char goal_alternative_offmemok
[MAX_RECOG_OPERANDS
];
2180 char goal_alternative_earlyclobber
[MAX_RECOG_OPERANDS
];
2181 int goal_alternative_swapped
;
2184 char operands_match
[MAX_RECOG_OPERANDS
][MAX_RECOG_OPERANDS
];
2185 rtx substed_operand
[MAX_RECOG_OPERANDS
];
2186 rtx body
= PATTERN (insn
);
2187 rtx set
= single_set (insn
);
2188 int goal_earlyclobber
, this_earlyclobber
;
2189 enum machine_mode operand_mode
[MAX_RECOG_OPERANDS
];
2192 this_insn_is_asm
= 0; /* Tentative. */
2196 n_earlyclobbers
= 0;
2197 replace_reloads
= replace
;
2198 hard_regs_live_known
= live_known
;
2199 static_reload_reg_p
= reload_reg_p
;
2201 /* JUMP_INSNs and CALL_INSNs are not allowed to have any output reloads;
2202 neither are insns that SET cc0. Insns that use CC0 are not allowed
2203 to have any input reloads. */
2204 if (GET_CODE (insn
) == JUMP_INSN
|| GET_CODE (insn
) == CALL_INSN
)
2205 no_output_reloads
= 1;
2208 if (reg_referenced_p (cc0_rtx
, PATTERN (insn
)))
2209 no_input_reloads
= 1;
2210 if (reg_set_p (cc0_rtx
, PATTERN (insn
)))
2211 no_output_reloads
= 1;
2214 #ifdef SECONDARY_MEMORY_NEEDED
2215 /* The eliminated forms of any secondary memory locations are per-insn, so
2216 clear them out here. */
2218 bzero ((char *) secondary_memlocs_elim
, sizeof secondary_memlocs_elim
);
2221 /* Find what kind of insn this is. NOPERANDS gets number of operands.
2222 Make OPERANDS point to a vector of operand values.
2223 Make OPERAND_LOCS point to a vector of pointers to
2224 where the operands were found.
2225 Fill CONSTRAINTS and CONSTRAINTS1 with pointers to the
2226 constraint-strings for this insn.
2227 Return if the insn needs no reload processing. */
2229 switch (GET_CODE (body
))
2239 /* Dispose quickly of (set (reg..) (reg..)) if both have hard regs and it
2240 is cheap to move between them. If it is not, there may not be an insn
2241 to do the copy, so we may need a reload. */
2242 if (GET_CODE (SET_DEST (body
)) == REG
2243 && REGNO (SET_DEST (body
)) < FIRST_PSEUDO_REGISTER
2244 && GET_CODE (SET_SRC (body
)) == REG
2245 && REGNO (SET_SRC (body
)) < FIRST_PSEUDO_REGISTER
2246 && REGISTER_MOVE_COST (REGNO_REG_CLASS (REGNO (SET_SRC (body
))),
2247 REGNO_REG_CLASS (REGNO (SET_DEST (body
)))) == 2)
2251 reload_n_operands
= noperands
= asm_noperands (body
);
2254 /* This insn is an `asm' with operands. */
2256 insn_code_number
= -1;
2257 this_insn_is_asm
= 1;
2259 /* expand_asm_operands makes sure there aren't too many operands. */
2260 if (noperands
> MAX_RECOG_OPERANDS
)
2263 /* Now get the operand values and constraints out of the insn. */
2265 decode_asm_operands (body
, recog_operand
, recog_operand_loc
,
2266 constraints
, operand_mode
);
2269 bcopy ((char *) constraints
, (char *) constraints1
,
2270 noperands
* sizeof (char *));
2271 n_alternatives
= n_occurrences (',', constraints
[0]) + 1;
2272 for (i
= 1; i
< noperands
; i
++)
2273 if (n_alternatives
!= n_occurrences (',', constraints
[i
]) + 1)
2275 error_for_asm (insn
, "operand constraints differ in number of alternatives");
2276 /* Avoid further trouble with this insn. */
2277 PATTERN (insn
) = gen_rtx (USE
, VOIDmode
, const0_rtx
);
2286 /* Ordinary insn: recognize it, get the operands via insn_extract
2287 and get the constraints. */
2289 insn_code_number
= recog_memoized (insn
);
2290 if (insn_code_number
< 0)
2291 fatal_insn_not_found (insn
);
2293 reload_n_operands
= noperands
= insn_n_operands
[insn_code_number
];
2294 n_alternatives
= insn_n_alternatives
[insn_code_number
];
2295 /* Just return "no reloads" if insn has no operands with constraints. */
2296 if (n_alternatives
== 0)
2298 insn_extract (insn
);
2299 for (i
= 0; i
< noperands
; i
++)
2301 constraints
[i
] = constraints1
[i
]
2302 = insn_operand_constraint
[insn_code_number
][i
];
2303 operand_mode
[i
] = insn_operand_mode
[insn_code_number
][i
];
2312 /* If we will need to know, later, whether some pair of operands
2313 are the same, we must compare them now and save the result.
2314 Reloading the base and index registers will clobber them
2315 and afterward they will fail to match. */
2317 for (i
= 0; i
< noperands
; i
++)
2322 substed_operand
[i
] = recog_operand
[i
];
2325 modified
[i
] = RELOAD_READ
;
2327 /* Scan this operand's constraint to see if it is an output operand,
2328 an in-out operand, is commutative, or should match another. */
2333 modified
[i
] = RELOAD_WRITE
;
2335 modified
[i
] = RELOAD_READ_WRITE
;
2338 /* The last operand should not be marked commutative. */
2339 if (i
== noperands
- 1)
2341 if (this_insn_is_asm
)
2342 warning_for_asm (this_insn
,
2343 "`%%' constraint used with last operand");
2350 else if (c
>= '0' && c
<= '9')
2353 operands_match
[c
][i
]
2354 = operands_match_p (recog_operand
[c
], recog_operand
[i
]);
2356 /* An operand may not match itself. */
2359 if (this_insn_is_asm
)
2360 warning_for_asm (this_insn
,
2361 "operand %d has constraint %d", i
, c
);
2366 /* If C can be commuted with C+1, and C might need to match I,
2367 then C+1 might also need to match I. */
2368 if (commutative
>= 0)
2370 if (c
== commutative
|| c
== commutative
+ 1)
2372 int other
= c
+ (c
== commutative
? 1 : -1);
2373 operands_match
[other
][i
]
2374 = operands_match_p (recog_operand
[other
], recog_operand
[i
]);
2376 if (i
== commutative
|| i
== commutative
+ 1)
2378 int other
= i
+ (i
== commutative
? 1 : -1);
2379 operands_match
[c
][other
]
2380 = operands_match_p (recog_operand
[c
], recog_operand
[other
]);
2382 /* Note that C is supposed to be less than I.
2383 No need to consider altering both C and I because in
2384 that case we would alter one into the other. */
2390 /* Examine each operand that is a memory reference or memory address
2391 and reload parts of the addresses into index registers.
2392 Also here any references to pseudo regs that didn't get hard regs
2393 but are equivalent to constants get replaced in the insn itself
2394 with those constants. Nobody will ever see them again.
2396 Finally, set up the preferred classes of each operand. */
2398 for (i
= 0; i
< noperands
; i
++)
2400 register RTX_CODE code
= GET_CODE (recog_operand
[i
]);
2402 address_reloaded
[i
] = 0;
2403 operand_type
[i
] = (modified
[i
] == RELOAD_READ
? RELOAD_FOR_INPUT
2404 : modified
[i
] == RELOAD_WRITE
? RELOAD_FOR_OUTPUT
2407 = (modified
[i
] == RELOAD_READ
? RELOAD_FOR_INPUT_ADDRESS
2408 : modified
[i
] == RELOAD_WRITE
? RELOAD_FOR_OUTPUT_ADDRESS
2411 if (*constraints
[i
] == 0)
2412 /* Ignore things like match_operator operands. */
2414 else if (constraints
[i
][0] == 'p')
2416 find_reloads_address (VOIDmode
, NULL_PTR
,
2417 recog_operand
[i
], recog_operand_loc
[i
],
2418 i
, operand_type
[i
], ind_levels
);
2419 substed_operand
[i
] = recog_operand
[i
] = *recog_operand_loc
[i
];
2421 else if (code
== MEM
)
2423 if (find_reloads_address (GET_MODE (recog_operand
[i
]),
2424 recog_operand_loc
[i
],
2425 XEXP (recog_operand
[i
], 0),
2426 &XEXP (recog_operand
[i
], 0),
2427 i
, address_type
[i
], ind_levels
))
2428 address_reloaded
[i
] = 1;
2429 substed_operand
[i
] = recog_operand
[i
] = *recog_operand_loc
[i
];
2431 else if (code
== SUBREG
)
2432 substed_operand
[i
] = recog_operand
[i
] = *recog_operand_loc
[i
]
2433 = find_reloads_toplev (recog_operand
[i
], i
, address_type
[i
],
2436 && &SET_DEST (set
) == recog_operand_loc
[i
]);
2437 else if (code
== PLUS
)
2438 /* We can get a PLUS as an "operand" as a result of
2439 register elimination. See eliminate_regs and gen_reload. */
2440 substed_operand
[i
] = recog_operand
[i
] = *recog_operand_loc
[i
]
2441 = find_reloads_toplev (recog_operand
[i
], i
, address_type
[i
],
2443 else if (code
== REG
)
2445 /* This is equivalent to calling find_reloads_toplev.
2446 The code is duplicated for speed.
2447 When we find a pseudo always equivalent to a constant,
2448 we replace it by the constant. We must be sure, however,
2449 that we don't try to replace it in the insn in which it
2451 register int regno
= REGNO (recog_operand
[i
]);
2452 if (reg_equiv_constant
[regno
] != 0
2453 && (set
== 0 || &SET_DEST (set
) != recog_operand_loc
[i
]))
2454 substed_operand
[i
] = recog_operand
[i
]
2455 = reg_equiv_constant
[regno
];
2456 #if 0 /* This might screw code in reload1.c to delete prior output-reload
2457 that feeds this insn. */
2458 if (reg_equiv_mem
[regno
] != 0)
2459 substed_operand
[i
] = recog_operand
[i
]
2460 = reg_equiv_mem
[regno
];
2462 if (reg_equiv_address
[regno
] != 0)
2464 /* If reg_equiv_address is not a constant address, copy it,
2465 since it may be shared. */
2466 /* We must rerun eliminate_regs, in case the elimination
2467 offsets have changed. */
2468 rtx address
= XEXP (eliminate_regs (reg_equiv_memory_loc
[regno
],
2472 if (rtx_varies_p (address
))
2473 address
= copy_rtx (address
);
2475 /* If this is an output operand, we must output a CLOBBER
2476 after INSN so find_equiv_reg knows REGNO is being written.
2477 Mark this insn specially, do we can put our output reloads
2480 if (modified
[i
] != RELOAD_READ
)
2481 PUT_MODE (emit_insn_after (gen_rtx (CLOBBER
, VOIDmode
,
2486 *recog_operand_loc
[i
] = recog_operand
[i
]
2487 = gen_rtx (MEM
, GET_MODE (recog_operand
[i
]), address
);
2488 RTX_UNCHANGING_P (recog_operand
[i
])
2489 = RTX_UNCHANGING_P (regno_reg_rtx
[regno
]);
2490 find_reloads_address (GET_MODE (recog_operand
[i
]),
2491 recog_operand_loc
[i
],
2492 XEXP (recog_operand
[i
], 0),
2493 &XEXP (recog_operand
[i
], 0),
2494 i
, address_type
[i
], ind_levels
);
2495 substed_operand
[i
] = recog_operand
[i
] = *recog_operand_loc
[i
];
2498 /* If the operand is still a register (we didn't replace it with an
2499 equivalent), get the preferred class to reload it into. */
2500 code
= GET_CODE (recog_operand
[i
]);
2502 = ((code
== REG
&& REGNO (recog_operand
[i
]) >= FIRST_PSEUDO_REGISTER
)
2503 ? reg_preferred_class (REGNO (recog_operand
[i
])) : NO_REGS
);
2505 = (code
== REG
&& REGNO (recog_operand
[i
]) >= FIRST_PSEUDO_REGISTER
2506 && reg_alternate_class (REGNO (recog_operand
[i
])) == NO_REGS
);
2509 /* If this is simply a copy from operand 1 to operand 0, merge the
2510 preferred classes for the operands. */
2511 if (set
!= 0 && noperands
>= 2 && recog_operand
[0] == SET_DEST (set
)
2512 && recog_operand
[1] == SET_SRC (set
))
2514 preferred_class
[0] = preferred_class
[1]
2515 = reg_class_subunion
[(int) preferred_class
[0]][(int) preferred_class
[1]];
2516 pref_or_nothing
[0] |= pref_or_nothing
[1];
2517 pref_or_nothing
[1] |= pref_or_nothing
[0];
2520 /* Now see what we need for pseudo-regs that didn't get hard regs
2521 or got the wrong kind of hard reg. For this, we must consider
2522 all the operands together against the register constraints. */
2524 best
= MAX_RECOG_OPERANDS
+ 300;
2527 goal_alternative_swapped
= 0;
2530 /* The constraints are made of several alternatives.
2531 Each operand's constraint looks like foo,bar,... with commas
2532 separating the alternatives. The first alternatives for all
2533 operands go together, the second alternatives go together, etc.
2535 First loop over alternatives. */
2537 for (this_alternative_number
= 0;
2538 this_alternative_number
< n_alternatives
;
2539 this_alternative_number
++)
2541 /* Loop over operands for one constraint alternative. */
2542 /* LOSERS counts those that don't fit this alternative
2543 and would require loading. */
2545 /* BAD is set to 1 if it some operand can't fit this alternative
2546 even after reloading. */
2548 /* REJECT is a count of how undesirable this alternative says it is
2549 if any reloading is required. If the alternative matches exactly
2550 then REJECT is ignored, but otherwise it gets this much
2551 counted against it in addition to the reloading needed. Each
2552 ? counts three times here since we want the disparaging caused by
2553 a bad register class to only count 1/3 as much. */
2556 this_earlyclobber
= 0;
2558 for (i
= 0; i
< noperands
; i
++)
2560 register char *p
= constraints
[i
];
2561 register int win
= 0;
2562 /* 0 => this operand can be reloaded somehow for this alternative */
2564 /* 0 => this operand can be reloaded if the alternative allows regs. */
2567 register rtx operand
= recog_operand
[i
];
2569 /* Nonzero means this is a MEM that must be reloaded into a reg
2570 regardless of what the constraint says. */
2571 int force_reload
= 0;
2573 /* Nonzero if a constant forced into memory would be OK for this
2576 int earlyclobber
= 0;
2578 /* If the operand is a SUBREG, extract
2579 the REG or MEM (or maybe even a constant) within.
2580 (Constants can occur as a result of reg_equiv_constant.) */
2582 while (GET_CODE (operand
) == SUBREG
)
2584 offset
+= SUBREG_WORD (operand
);
2585 operand
= SUBREG_REG (operand
);
2586 /* Force reload if this is a constant or PLUS or if there may may
2587 be a problem accessing OPERAND in the outer mode. */
2588 if (CONSTANT_P (operand
)
2589 || GET_CODE (operand
) == PLUS
2590 /* We must force a reload of paradoxical SUBREGs
2591 of a MEM because the alignment of the inner value
2592 may not be enough to do the outer reference. On
2593 big-endian machines, it may also reference outside
2596 On machines that extend byte operations and we have a
2597 SUBREG where both the inner and outer modes are no wider
2598 than a word and the inner mode is narrower, is integral,
2599 and gets extended when loaded from memory, combine.c has
2600 made assumptions about the behavior of the machine in such
2601 register access. If the data is, in fact, in memory we
2602 must always load using the size assumed to be in the
2603 register and let the insn do the different-sized
2605 || ((GET_CODE (operand
) == MEM
2606 || (GET_CODE (operand
)== REG
2607 && REGNO (operand
) >= FIRST_PSEUDO_REGISTER
))
2608 && (((GET_MODE_BITSIZE (GET_MODE (operand
))
2609 < BIGGEST_ALIGNMENT
)
2610 && (GET_MODE_SIZE (operand_mode
[i
])
2611 > GET_MODE_SIZE (GET_MODE (operand
))))
2612 || (GET_CODE (operand
) == MEM
&& BYTES_BIG_ENDIAN
)
2613 #ifdef LOAD_EXTEND_OP
2614 || (GET_MODE_SIZE (operand_mode
[i
]) <= UNITS_PER_WORD
2615 && (GET_MODE_SIZE (GET_MODE (operand
))
2617 && (GET_MODE_SIZE (operand_mode
[i
])
2618 > GET_MODE_SIZE (GET_MODE (operand
)))
2619 && INTEGRAL_MODE_P (GET_MODE (operand
))
2620 && LOAD_EXTEND_OP (GET_MODE (operand
)) != NIL
)
2623 /* Subreg of a hard reg which can't handle the subreg's mode
2624 or which would handle that mode in the wrong number of
2625 registers for subregging to work. */
2626 || (GET_CODE (operand
) == REG
2627 && REGNO (operand
) < FIRST_PSEUDO_REGISTER
2628 && ((GET_MODE_SIZE (operand_mode
[i
]) <= UNITS_PER_WORD
2629 && (GET_MODE_SIZE (GET_MODE (operand
))
2631 && ((GET_MODE_SIZE (GET_MODE (operand
))
2633 != HARD_REGNO_NREGS (REGNO (operand
),
2634 GET_MODE (operand
))))
2635 || ! HARD_REGNO_MODE_OK (REGNO (operand
) + offset
,
2640 this_alternative
[i
] = (int) NO_REGS
;
2641 this_alternative_win
[i
] = 0;
2642 this_alternative_offmemok
[i
] = 0;
2643 this_alternative_earlyclobber
[i
] = 0;
2644 this_alternative_matches
[i
] = -1;
2646 /* An empty constraint or empty alternative
2647 allows anything which matched the pattern. */
2648 if (*p
== 0 || *p
== ',')
2651 /* Scan this alternative's specs for this operand;
2652 set WIN if the operand fits any letter in this alternative.
2653 Otherwise, clear BADOP if this operand could
2654 fit some letter after reloads,
2655 or set WINREG if this operand could fit after reloads
2656 provided the constraint allows some registers. */
2658 while (*p
&& (c
= *p
++) != ',')
2667 /* The last operand should not be marked commutative. */
2668 if (i
!= noperands
- 1)
2681 /* Ignore rest of this alternative as far as
2682 reloading is concerned. */
2683 while (*p
&& *p
!= ',') p
++;
2692 this_alternative_matches
[i
] = c
;
2693 /* We are supposed to match a previous operand.
2694 If we do, we win if that one did.
2695 If we do not, count both of the operands as losers.
2696 (This is too conservative, since most of the time
2697 only a single reload insn will be needed to make
2698 the two operands win. As a result, this alternative
2699 may be rejected when it is actually desirable.) */
2700 if ((swapped
&& (c
!= commutative
|| i
!= commutative
+ 1))
2701 /* If we are matching as if two operands were swapped,
2702 also pretend that operands_match had been computed
2704 But if I is the second of those and C is the first,
2705 don't exchange them, because operands_match is valid
2706 only on one side of its diagonal. */
2708 [(c
== commutative
|| c
== commutative
+ 1)
2709 ? 2*commutative
+ 1 - c
: c
]
2710 [(i
== commutative
|| i
== commutative
+ 1)
2711 ? 2*commutative
+ 1 - i
: i
])
2712 : operands_match
[c
][i
])
2713 win
= this_alternative_win
[c
];
2716 /* Operands don't match. */
2718 /* Retroactively mark the operand we had to match
2719 as a loser, if it wasn't already. */
2720 if (this_alternative_win
[c
])
2722 this_alternative_win
[c
] = 0;
2723 if (this_alternative
[c
] == (int) NO_REGS
)
2725 /* But count the pair only once in the total badness of
2726 this alternative, if the pair can be a dummy reload. */
2728 = find_dummy_reload (recog_operand
[i
], recog_operand
[c
],
2729 recog_operand_loc
[i
], recog_operand_loc
[c
],
2730 operand_mode
[i
], operand_mode
[c
],
2731 this_alternative
[c
], -1);
2736 /* This can be fixed with reloads if the operand
2737 we are supposed to match can be fixed with reloads. */
2739 this_alternative
[i
] = this_alternative
[c
];
2741 /* If we have to reload this operand and some previous
2742 operand also had to match the same thing as this
2743 operand, we don't know how to do that. So reject this
2745 if (! win
|| force_reload
)
2746 for (j
= 0; j
< i
; j
++)
2747 if (this_alternative_matches
[j
]
2748 == this_alternative_matches
[i
])
2754 /* All necessary reloads for an address_operand
2755 were handled in find_reloads_address. */
2756 this_alternative
[i
] = (int) BASE_REG_CLASS
;
2763 if (GET_CODE (operand
) == MEM
2764 || (GET_CODE (operand
) == REG
2765 && REGNO (operand
) >= FIRST_PSEUDO_REGISTER
2766 && reg_renumber
[REGNO (operand
)] < 0))
2768 if (CONSTANT_P (operand
))
2774 if (GET_CODE (operand
) == MEM
2775 && ! address_reloaded
[i
]
2776 && (GET_CODE (XEXP (operand
, 0)) == PRE_DEC
2777 || GET_CODE (XEXP (operand
, 0)) == POST_DEC
))
2782 if (GET_CODE (operand
) == MEM
2783 && ! address_reloaded
[i
]
2784 && (GET_CODE (XEXP (operand
, 0)) == PRE_INC
2785 || GET_CODE (XEXP (operand
, 0)) == POST_INC
))
2789 /* Memory operand whose address is not offsettable. */
2793 if (GET_CODE (operand
) == MEM
2794 && ! (ind_levels
? offsettable_memref_p (operand
)
2795 : offsettable_nonstrict_memref_p (operand
))
2796 /* Certain mem addresses will become offsettable
2797 after they themselves are reloaded. This is important;
2798 we don't want our own handling of unoffsettables
2799 to override the handling of reg_equiv_address. */
2800 && !(GET_CODE (XEXP (operand
, 0)) == REG
2802 || reg_equiv_address
[REGNO (XEXP (operand
, 0))] != 0)))
2806 /* Memory operand whose address is offsettable. */
2810 if ((GET_CODE (operand
) == MEM
2811 /* If IND_LEVELS, find_reloads_address won't reload a
2812 pseudo that didn't get a hard reg, so we have to
2813 reject that case. */
2814 && (ind_levels
? offsettable_memref_p (operand
)
2815 : offsettable_nonstrict_memref_p (operand
)))
2816 /* A reloaded auto-increment address is offsettable,
2817 because it is now just a simple register indirect. */
2818 || (GET_CODE (operand
) == MEM
2819 && address_reloaded
[i
]
2820 && (GET_CODE (XEXP (operand
, 0)) == PRE_INC
2821 || GET_CODE (XEXP (operand
, 0)) == PRE_DEC
2822 || GET_CODE (XEXP (operand
, 0)) == POST_INC
2823 || GET_CODE (XEXP (operand
, 0)) == POST_DEC
))
2824 /* Certain mem addresses will become offsettable
2825 after they themselves are reloaded. This is important;
2826 we don't want our own handling of unoffsettables
2827 to override the handling of reg_equiv_address. */
2828 || (GET_CODE (operand
) == MEM
2829 && GET_CODE (XEXP (operand
, 0)) == REG
2831 || reg_equiv_address
[REGNO (XEXP (operand
, 0))] != 0))
2832 || (GET_CODE (operand
) == REG
2833 && REGNO (operand
) >= FIRST_PSEUDO_REGISTER
2834 && reg_renumber
[REGNO (operand
)] < 0
2835 /* If reg_equiv_address is nonzero, we will be
2836 loading it into a register; hence it will be
2837 offsettable, but we cannot say that reg_equiv_mem
2838 is offsettable without checking. */
2839 && ((reg_equiv_mem
[REGNO (operand
)] != 0
2840 && offsettable_memref_p (reg_equiv_mem
[REGNO (operand
)]))
2841 || (reg_equiv_address
[REGNO (operand
)] != 0))))
2843 if (CONSTANT_P (operand
) || GET_CODE (operand
) == MEM
)
2850 /* Output operand that is stored before the need for the
2851 input operands (and their index registers) is over. */
2852 earlyclobber
= 1, this_earlyclobber
= 1;
2856 #ifndef REAL_ARITHMETIC
2857 /* Match any floating double constant, but only if
2858 we can examine the bits of it reliably. */
2859 if ((HOST_FLOAT_FORMAT
!= TARGET_FLOAT_FORMAT
2860 || HOST_BITS_PER_WIDE_INT
!= BITS_PER_WORD
)
2861 && GET_MODE (operand
) != VOIDmode
&& ! flag_pretend_float
)
2864 if (GET_CODE (operand
) == CONST_DOUBLE
)
2869 if (GET_CODE (operand
) == CONST_DOUBLE
)
2875 if (GET_CODE (operand
) == CONST_DOUBLE
2876 && CONST_DOUBLE_OK_FOR_LETTER_P (operand
, c
))
2881 if (GET_CODE (operand
) == CONST_INT
2882 || (GET_CODE (operand
) == CONST_DOUBLE
2883 && GET_MODE (operand
) == VOIDmode
))
2886 if (CONSTANT_P (operand
)
2887 #ifdef LEGITIMATE_PIC_OPERAND_P
2888 && (! flag_pic
|| LEGITIMATE_PIC_OPERAND_P (operand
))
2895 if (GET_CODE (operand
) == CONST_INT
2896 || (GET_CODE (operand
) == CONST_DOUBLE
2897 && GET_MODE (operand
) == VOIDmode
))
2909 if (GET_CODE (operand
) == CONST_INT
2910 && CONST_OK_FOR_LETTER_P (INTVAL (operand
), c
))
2920 /* A PLUS is never a valid operand, but reload can make
2921 it from a register when eliminating registers. */
2922 && GET_CODE (operand
) != PLUS
2923 /* A SCRATCH is not a valid operand. */
2924 && GET_CODE (operand
) != SCRATCH
2925 #ifdef LEGITIMATE_PIC_OPERAND_P
2926 && (! CONSTANT_P (operand
)
2928 || LEGITIMATE_PIC_OPERAND_P (operand
))
2930 && (GENERAL_REGS
== ALL_REGS
2931 || GET_CODE (operand
) != REG
2932 || (REGNO (operand
) >= FIRST_PSEUDO_REGISTER
2933 && reg_renumber
[REGNO (operand
)] < 0)))
2935 /* Drop through into 'r' case */
2939 = (int) reg_class_subunion
[this_alternative
[i
]][(int) GENERAL_REGS
];
2942 #ifdef EXTRA_CONSTRAINT
2948 if (EXTRA_CONSTRAINT (operand
, c
))
2955 = (int) reg_class_subunion
[this_alternative
[i
]][(int) REG_CLASS_FROM_LETTER (c
)];
2958 if (GET_MODE (operand
) == BLKmode
)
2961 if (GET_CODE (operand
) == REG
2962 && reg_fits_class_p (operand
, this_alternative
[i
],
2963 offset
, GET_MODE (recog_operand
[i
])))
2970 /* If this operand could be handled with a reg,
2971 and some reg is allowed, then this operand can be handled. */
2972 if (winreg
&& this_alternative
[i
] != (int) NO_REGS
)
2975 /* Record which operands fit this alternative. */
2976 this_alternative_earlyclobber
[i
] = earlyclobber
;
2977 if (win
&& ! force_reload
)
2978 this_alternative_win
[i
] = 1;
2981 int const_to_mem
= 0;
2983 this_alternative_offmemok
[i
] = offmemok
;
2987 /* Alternative loses if it has no regs for a reg operand. */
2988 if (GET_CODE (operand
) == REG
2989 && this_alternative
[i
] == (int) NO_REGS
2990 && this_alternative_matches
[i
] < 0)
2993 /* Alternative loses if it requires a type of reload not
2994 permitted for this insn. We can always reload SCRATCH
2995 and objects with a REG_UNUSED note. */
2996 if (GET_CODE (operand
) != SCRATCH
2997 && modified
[i
] != RELOAD_READ
&& no_output_reloads
2998 && ! find_reg_note (insn
, REG_UNUSED
, operand
))
3000 else if (modified
[i
] != RELOAD_WRITE
&& no_input_reloads
)
3003 /* If this is a constant that is reloaded into the desired
3004 class by copying it to memory first, count that as another
3005 reload. This is consistent with other code and is
3006 required to avoid choosing another alternative when
3007 the constant is moved into memory by this function on
3008 an early reload pass. Note that the test here is
3009 precisely the same as in the code below that calls
3011 if (CONSTANT_P (operand
)
3012 /* force_const_mem does not accept HIGH. */
3013 && GET_CODE (operand
) != HIGH
3014 && (PREFERRED_RELOAD_CLASS (operand
,
3015 (enum reg_class
) this_alternative
[i
])
3017 && operand_mode
[i
] != VOIDmode
)
3020 if (this_alternative
[i
] != (int) NO_REGS
)
3024 /* If we can't reload this value at all, reject this
3025 alternative. Note that we could also lose due to
3026 LIMIT_RELOAD_RELOAD_CLASS, but we don't check that
3029 if (! CONSTANT_P (operand
)
3030 && (enum reg_class
) this_alternative
[i
] != NO_REGS
3031 && (PREFERRED_RELOAD_CLASS (operand
,
3032 (enum reg_class
) this_alternative
[i
])
3036 /* We prefer to reload pseudos over reloading other things,
3037 since such reloads may be able to be eliminated later.
3038 If we are reloading a SCRATCH, we won't be generating any
3039 insns, just using a register, so it is also preferred.
3040 So bump REJECT in other cases. Don't do this in the
3041 case where we are forcing a constant into memory and
3042 it will then win since we don't want to have a different
3043 alternative match then. */
3044 if (! (GET_CODE (operand
) == REG
3045 && REGNO (operand
) >= FIRST_PSEUDO_REGISTER
)
3046 && GET_CODE (operand
) != SCRATCH
3047 && ! (const_to_mem
&& constmemok
))
3051 /* If this operand is a pseudo register that didn't get a hard
3052 reg and this alternative accepts some register, see if the
3053 class that we want is a subset of the preferred class for this
3054 register. If not, but it intersects that class, use the
3055 preferred class instead. If it does not intersect the preferred
3056 class, show that usage of this alternative should be discouraged;
3057 it will be discouraged more still if the register is `preferred
3058 or nothing'. We do this because it increases the chance of
3059 reusing our spill register in a later insn and avoiding a pair
3060 of memory stores and loads.
3062 Don't bother with this if this alternative will accept this
3065 Don't do this for a multiword operand, since it is only a
3066 small win and has the risk of requiring more spill registers,
3067 which could cause a large loss.
3069 Don't do this if the preferred class has only one register
3070 because we might otherwise exhaust the class. */
3073 if (! win
&& this_alternative
[i
] != (int) NO_REGS
3074 && GET_MODE_SIZE (operand_mode
[i
]) <= UNITS_PER_WORD
3075 && reg_class_size
[(int) preferred_class
[i
]] > 1)
3077 if (! reg_class_subset_p (this_alternative
[i
],
3078 preferred_class
[i
]))
3080 /* Since we don't have a way of forming the intersection,
3081 we just do something special if the preferred class
3082 is a subset of the class we have; that's the most
3083 common case anyway. */
3084 if (reg_class_subset_p (preferred_class
[i
],
3085 this_alternative
[i
]))
3086 this_alternative
[i
] = (int) preferred_class
[i
];
3088 reject
+= (1 + pref_or_nothing
[i
]);
3093 /* Now see if any output operands that are marked "earlyclobber"
3094 in this alternative conflict with any input operands
3095 or any memory addresses. */
3097 for (i
= 0; i
< noperands
; i
++)
3098 if (this_alternative_earlyclobber
[i
]
3099 && this_alternative_win
[i
])
3101 struct decomposition early_data
;
3103 early_data
= decompose (recog_operand
[i
]);
3105 if (modified
[i
] == RELOAD_READ
)
3107 if (this_insn_is_asm
)
3108 warning_for_asm (this_insn
,
3109 "`&' constraint used with input operand");
3115 if (this_alternative
[i
] == NO_REGS
)
3117 this_alternative_earlyclobber
[i
] = 0;
3118 if (this_insn_is_asm
)
3119 error_for_asm (this_insn
,
3120 "`&' constraint used with no register class");
3125 for (j
= 0; j
< noperands
; j
++)
3126 /* Is this an input operand or a memory ref? */
3127 if ((GET_CODE (recog_operand
[j
]) == MEM
3128 || modified
[j
] != RELOAD_WRITE
)
3130 /* Ignore things like match_operator operands. */
3131 && *constraints1
[j
] != 0
3132 /* Don't count an input operand that is constrained to match
3133 the early clobber operand. */
3134 && ! (this_alternative_matches
[j
] == i
3135 && rtx_equal_p (recog_operand
[i
], recog_operand
[j
]))
3136 /* Is it altered by storing the earlyclobber operand? */
3137 && !immune_p (recog_operand
[j
], recog_operand
[i
], early_data
))
3139 /* If the output is in a single-reg class,
3140 it's costly to reload it, so reload the input instead. */
3141 if (reg_class_size
[this_alternative
[i
]] == 1
3142 && (GET_CODE (recog_operand
[j
]) == REG
3143 || GET_CODE (recog_operand
[j
]) == SUBREG
))
3146 this_alternative_win
[j
] = 0;
3151 /* If an earlyclobber operand conflicts with something,
3152 it must be reloaded, so request this and count the cost. */
3156 this_alternative_win
[i
] = 0;
3157 for (j
= 0; j
< noperands
; j
++)
3158 if (this_alternative_matches
[j
] == i
3159 && this_alternative_win
[j
])
3161 this_alternative_win
[j
] = 0;
3167 /* If one alternative accepts all the operands, no reload required,
3168 choose that alternative; don't consider the remaining ones. */
3171 /* Unswap these so that they are never swapped at `finish'. */
3172 if (commutative
>= 0)
3174 recog_operand
[commutative
] = substed_operand
[commutative
];
3175 recog_operand
[commutative
+ 1]
3176 = substed_operand
[commutative
+ 1];
3178 for (i
= 0; i
< noperands
; i
++)
3180 goal_alternative_win
[i
] = 1;
3181 goal_alternative
[i
] = this_alternative
[i
];
3182 goal_alternative_offmemok
[i
] = this_alternative_offmemok
[i
];
3183 goal_alternative_matches
[i
] = this_alternative_matches
[i
];
3184 goal_alternative_earlyclobber
[i
]
3185 = this_alternative_earlyclobber
[i
];
3187 goal_alternative_number
= this_alternative_number
;
3188 goal_alternative_swapped
= swapped
;
3189 goal_earlyclobber
= this_earlyclobber
;
3193 /* REJECT, set by the ! and ? constraint characters and when a register
3194 would be reloaded into a non-preferred class, discourages the use of
3195 this alternative for a reload goal. REJECT is incremented by three
3196 for each ? and one for each non-preferred class. */
3197 losers
= losers
* 3 + reject
;
3199 /* If this alternative can be made to work by reloading,
3200 and it needs less reloading than the others checked so far,
3201 record it as the chosen goal for reloading. */
3202 if (! bad
&& best
> losers
)
3204 for (i
= 0; i
< noperands
; i
++)
3206 goal_alternative
[i
] = this_alternative
[i
];
3207 goal_alternative_win
[i
] = this_alternative_win
[i
];
3208 goal_alternative_offmemok
[i
] = this_alternative_offmemok
[i
];
3209 goal_alternative_matches
[i
] = this_alternative_matches
[i
];
3210 goal_alternative_earlyclobber
[i
]
3211 = this_alternative_earlyclobber
[i
];
3213 goal_alternative_swapped
= swapped
;
3215 goal_alternative_number
= this_alternative_number
;
3216 goal_earlyclobber
= this_earlyclobber
;
3220 /* If insn is commutative (it's safe to exchange a certain pair of operands)
3221 then we need to try each alternative twice,
3222 the second time matching those two operands
3223 as if we had exchanged them.
3224 To do this, really exchange them in operands.
3226 If we have just tried the alternatives the second time,
3227 return operands to normal and drop through. */
3229 if (commutative
>= 0)
3234 register enum reg_class tclass
;
3237 recog_operand
[commutative
] = substed_operand
[commutative
+ 1];
3238 recog_operand
[commutative
+ 1] = substed_operand
[commutative
];
3240 tclass
= preferred_class
[commutative
];
3241 preferred_class
[commutative
] = preferred_class
[commutative
+ 1];
3242 preferred_class
[commutative
+ 1] = tclass
;
3244 t
= pref_or_nothing
[commutative
];
3245 pref_or_nothing
[commutative
] = pref_or_nothing
[commutative
+ 1];
3246 pref_or_nothing
[commutative
+ 1] = t
;
3248 bcopy ((char *) constraints1
, (char *) constraints
,
3249 noperands
* sizeof (char *));
3254 recog_operand
[commutative
] = substed_operand
[commutative
];
3255 recog_operand
[commutative
+ 1] = substed_operand
[commutative
+ 1];
3259 /* The operands don't meet the constraints.
3260 goal_alternative describes the alternative
3261 that we could reach by reloading the fewest operands.
3262 Reload so as to fit it. */
3264 if (best
== MAX_RECOG_OPERANDS
+ 300)
3266 /* No alternative works with reloads?? */
3267 if (insn_code_number
>= 0)
3269 error_for_asm (insn
, "inconsistent operand constraints in an `asm'");
3270 /* Avoid further trouble with this insn. */
3271 PATTERN (insn
) = gen_rtx (USE
, VOIDmode
, const0_rtx
);
3276 /* Jump to `finish' from above if all operands are valid already.
3277 In that case, goal_alternative_win is all 1. */
3280 /* Right now, for any pair of operands I and J that are required to match,
3282 goal_alternative_matches[J] is I.
3283 Set up goal_alternative_matched as the inverse function:
3284 goal_alternative_matched[I] = J. */
3286 for (i
= 0; i
< noperands
; i
++)
3287 goal_alternative_matched
[i
] = -1;
3289 for (i
= 0; i
< noperands
; i
++)
3290 if (! goal_alternative_win
[i
]
3291 && goal_alternative_matches
[i
] >= 0)
3292 goal_alternative_matched
[goal_alternative_matches
[i
]] = i
;
3294 /* If the best alternative is with operands 1 and 2 swapped,
3295 consider them swapped before reporting the reloads. Update the
3296 operand numbers of any reloads already pushed. */
3298 if (goal_alternative_swapped
)
3302 tem
= substed_operand
[commutative
];
3303 substed_operand
[commutative
] = substed_operand
[commutative
+ 1];
3304 substed_operand
[commutative
+ 1] = tem
;
3305 tem
= recog_operand
[commutative
];
3306 recog_operand
[commutative
] = recog_operand
[commutative
+ 1];
3307 recog_operand
[commutative
+ 1] = tem
;
3309 for (i
= 0; i
< n_reloads
; i
++)
3311 if (reload_opnum
[i
] == commutative
)
3312 reload_opnum
[i
] = commutative
+ 1;
3313 else if (reload_opnum
[i
] == commutative
+ 1)
3314 reload_opnum
[i
] = commutative
;
3318 /* Perform whatever substitutions on the operands we are supposed
3319 to make due to commutativity or replacement of registers
3320 with equivalent constants or memory slots. */
3322 for (i
= 0; i
< noperands
; i
++)
3324 *recog_operand_loc
[i
] = substed_operand
[i
];
3325 /* While we are looping on operands, initialize this. */
3326 operand_reloadnum
[i
] = -1;
3328 /* If this is an earlyclobber operand, we need to widen the scope.
3329 The reload must remain valid from the start of the insn being
3330 reloaded until after the operand is stored into its destination.
3331 We approximate this with RELOAD_OTHER even though we know that we
3332 do not conflict with RELOAD_FOR_INPUT_ADDRESS reloads.
3334 One special case that is worth checking is when we have an
3335 output that is earlyclobber but isn't used past the insn (typically
3336 a SCRATCH). In this case, we only need have the reload live
3337 through the insn itself, but not for any of our input or output
3340 In any case, anything needed to address this operand can remain
3341 however they were previously categorized. */
3343 if (goal_alternative_earlyclobber
[i
])
3345 = (find_reg_note (insn
, REG_UNUSED
, recog_operand
[i
])
3346 ? RELOAD_FOR_INSN
: RELOAD_OTHER
);
3349 /* Any constants that aren't allowed and can't be reloaded
3350 into registers are here changed into memory references. */
3351 for (i
= 0; i
< noperands
; i
++)
3352 if (! goal_alternative_win
[i
]
3353 && CONSTANT_P (recog_operand
[i
])
3354 /* force_const_mem does not accept HIGH. */
3355 && GET_CODE (recog_operand
[i
]) != HIGH
3356 && (PREFERRED_RELOAD_CLASS (recog_operand
[i
],
3357 (enum reg_class
) goal_alternative
[i
])
3359 && operand_mode
[i
] != VOIDmode
)
3361 *recog_operand_loc
[i
] = recog_operand
[i
]
3362 = find_reloads_toplev (force_const_mem (operand_mode
[i
],
3364 i
, address_type
[i
], ind_levels
, 0);
3365 if (alternative_allows_memconst (constraints1
[i
],
3366 goal_alternative_number
))
3367 goal_alternative_win
[i
] = 1;
3370 /* Record the values of the earlyclobber operands for the caller. */
3371 if (goal_earlyclobber
)
3372 for (i
= 0; i
< noperands
; i
++)
3373 if (goal_alternative_earlyclobber
[i
])
3374 reload_earlyclobbers
[n_earlyclobbers
++] = recog_operand
[i
];
3376 /* Now record reloads for all the operands that need them. */
3377 for (i
= 0; i
< noperands
; i
++)
3378 if (! goal_alternative_win
[i
])
3380 /* Operands that match previous ones have already been handled. */
3381 if (goal_alternative_matches
[i
] >= 0)
3383 /* Handle an operand with a nonoffsettable address
3384 appearing where an offsettable address will do
3385 by reloading the address into a base register.
3387 ??? We can also do this when the operand is a register and
3388 reg_equiv_mem is not offsettable, but this is a bit tricky,
3389 so we don't bother with it. It may not be worth doing. */
3390 else if (goal_alternative_matched
[i
] == -1
3391 && goal_alternative_offmemok
[i
]
3392 && GET_CODE (recog_operand
[i
]) == MEM
)
3394 operand_reloadnum
[i
]
3395 = push_reload (XEXP (recog_operand
[i
], 0), NULL_RTX
,
3396 &XEXP (recog_operand
[i
], 0), NULL_PTR
,
3397 BASE_REG_CLASS
, GET_MODE (XEXP (recog_operand
[i
], 0)),
3398 VOIDmode
, 0, 0, i
, RELOAD_FOR_INPUT
);
3399 reload_inc
[operand_reloadnum
[i
]]
3400 = GET_MODE_SIZE (GET_MODE (recog_operand
[i
]));
3402 /* If this operand is an output, we will have made any
3403 reloads for its address as RELOAD_FOR_OUTPUT_ADDRESS, but
3404 now we are treating part of the operand as an input, so
3405 we must change these to RELOAD_FOR_INPUT_ADDRESS. */
3407 if (modified
[i
] == RELOAD_WRITE
)
3408 for (j
= 0; j
< n_reloads
; j
++)
3409 if (reload_opnum
[j
] == i
3410 && reload_when_needed
[j
] == RELOAD_FOR_OUTPUT_ADDRESS
)
3411 reload_when_needed
[j
] = RELOAD_FOR_INPUT_ADDRESS
;
3413 else if (goal_alternative_matched
[i
] == -1)
3414 operand_reloadnum
[i
] =
3415 push_reload (modified
[i
] != RELOAD_WRITE
? recog_operand
[i
] : 0,
3416 modified
[i
] != RELOAD_READ
? recog_operand
[i
] : 0,
3417 (modified
[i
] != RELOAD_WRITE
?
3418 recog_operand_loc
[i
] : 0),
3419 modified
[i
] != RELOAD_READ
? recog_operand_loc
[i
] : 0,
3420 (enum reg_class
) goal_alternative
[i
],
3421 (modified
[i
] == RELOAD_WRITE
3422 ? VOIDmode
: operand_mode
[i
]),
3423 (modified
[i
] == RELOAD_READ
3424 ? VOIDmode
: operand_mode
[i
]),
3425 (insn_code_number
< 0 ? 0
3426 : insn_operand_strict_low
[insn_code_number
][i
]),
3427 0, i
, operand_type
[i
]);
3428 /* In a matching pair of operands, one must be input only
3429 and the other must be output only.
3430 Pass the input operand as IN and the other as OUT. */
3431 else if (modified
[i
] == RELOAD_READ
3432 && modified
[goal_alternative_matched
[i
]] == RELOAD_WRITE
)
3434 operand_reloadnum
[i
]
3435 = push_reload (recog_operand
[i
],
3436 recog_operand
[goal_alternative_matched
[i
]],
3437 recog_operand_loc
[i
],
3438 recog_operand_loc
[goal_alternative_matched
[i
]],
3439 (enum reg_class
) goal_alternative
[i
],
3441 operand_mode
[goal_alternative_matched
[i
]],
3442 0, 0, i
, RELOAD_OTHER
);
3443 operand_reloadnum
[goal_alternative_matched
[i
]] = output_reloadnum
;
3445 else if (modified
[i
] == RELOAD_WRITE
3446 && modified
[goal_alternative_matched
[i
]] == RELOAD_READ
)
3448 operand_reloadnum
[goal_alternative_matched
[i
]]
3449 = push_reload (recog_operand
[goal_alternative_matched
[i
]],
3451 recog_operand_loc
[goal_alternative_matched
[i
]],
3452 recog_operand_loc
[i
],
3453 (enum reg_class
) goal_alternative
[i
],
3454 operand_mode
[goal_alternative_matched
[i
]],
3456 0, 0, i
, RELOAD_OTHER
);
3457 operand_reloadnum
[i
] = output_reloadnum
;
3459 else if (insn_code_number
>= 0)
3463 error_for_asm (insn
, "inconsistent operand constraints in an `asm'");
3464 /* Avoid further trouble with this insn. */
3465 PATTERN (insn
) = gen_rtx (USE
, VOIDmode
, const0_rtx
);
3470 else if (goal_alternative_matched
[i
] < 0
3471 && goal_alternative_matches
[i
] < 0
3474 /* For each non-matching operand that's a MEM or a pseudo-register
3475 that didn't get a hard register, make an optional reload.
3476 This may get done even if the insn needs no reloads otherwise. */
3478 rtx operand
= recog_operand
[i
];
3480 while (GET_CODE (operand
) == SUBREG
)
3481 operand
= XEXP (operand
, 0);
3482 if ((GET_CODE (operand
) == MEM
3483 || (GET_CODE (operand
) == REG
3484 && REGNO (operand
) >= FIRST_PSEUDO_REGISTER
))
3485 && (enum reg_class
) goal_alternative
[i
] != NO_REGS
3486 && ! no_input_reloads
3487 /* Optional output reloads don't do anything and we mustn't
3488 make in-out reloads on insns that are not permitted output
3490 && (modified
[i
] == RELOAD_READ
3491 || (modified
[i
] == RELOAD_READ_WRITE
&& ! no_output_reloads
)))
3492 operand_reloadnum
[i
]
3493 = push_reload (modified
[i
] != RELOAD_WRITE
? recog_operand
[i
] : 0,
3494 modified
[i
] != RELOAD_READ
? recog_operand
[i
] : 0,
3495 (modified
[i
] != RELOAD_WRITE
3496 ? recog_operand_loc
[i
] : 0),
3497 (modified
[i
] != RELOAD_READ
3498 ? recog_operand_loc
[i
] : 0),
3499 (enum reg_class
) goal_alternative
[i
],
3500 (modified
[i
] == RELOAD_WRITE
3501 ? VOIDmode
: operand_mode
[i
]),
3502 (modified
[i
] == RELOAD_READ
3503 ? VOIDmode
: operand_mode
[i
]),
3504 (insn_code_number
< 0 ? 0
3505 : insn_operand_strict_low
[insn_code_number
][i
]),
3506 1, i
, operand_type
[i
]);
3508 else if (goal_alternative_matches
[i
] >= 0
3509 && goal_alternative_win
[goal_alternative_matches
[i
]]
3510 && modified
[i
] == RELOAD_READ
3511 && modified
[goal_alternative_matches
[i
]] == RELOAD_WRITE
3512 && ! no_input_reloads
&& ! no_output_reloads
3515 /* Similarly, make an optional reload for a pair of matching
3516 objects that are in MEM or a pseudo that didn't get a hard reg. */
3518 rtx operand
= recog_operand
[i
];
3520 while (GET_CODE (operand
) == SUBREG
)
3521 operand
= XEXP (operand
, 0);
3522 if ((GET_CODE (operand
) == MEM
3523 || (GET_CODE (operand
) == REG
3524 && REGNO (operand
) >= FIRST_PSEUDO_REGISTER
))
3525 && ((enum reg_class
) goal_alternative
[goal_alternative_matches
[i
]]
3527 operand_reloadnum
[i
] = operand_reloadnum
[goal_alternative_matches
[i
]]
3528 = push_reload (recog_operand
[goal_alternative_matches
[i
]],
3530 recog_operand_loc
[goal_alternative_matches
[i
]],
3531 recog_operand_loc
[i
],
3532 (enum reg_class
) goal_alternative
[goal_alternative_matches
[i
]],
3533 operand_mode
[goal_alternative_matches
[i
]],
3535 0, 1, goal_alternative_matches
[i
], RELOAD_OTHER
);
3538 /* If this insn pattern contains any MATCH_DUP's, make sure that
3539 they will be substituted if the operands they match are substituted.
3540 Also do now any substitutions we already did on the operands.
3542 Don't do this if we aren't making replacements because we might be
3543 propagating things allocated by frame pointer elimination into places
3544 it doesn't expect. */
3546 if (insn_code_number
>= 0 && replace
)
3547 for (i
= insn_n_dups
[insn_code_number
] - 1; i
>= 0; i
--)
3549 int opno
= recog_dup_num
[i
];
3550 *recog_dup_loc
[i
] = *recog_operand_loc
[opno
];
3551 if (operand_reloadnum
[opno
] >= 0)
3552 push_replacement (recog_dup_loc
[i
], operand_reloadnum
[opno
],
3553 insn_operand_mode
[insn_code_number
][opno
]);
3557 /* This loses because reloading of prior insns can invalidate the equivalence
3558 (or at least find_equiv_reg isn't smart enough to find it any more),
3559 causing this insn to need more reload regs than it needed before.
3560 It may be too late to make the reload regs available.
3561 Now this optimization is done safely in choose_reload_regs. */
3563 /* For each reload of a reg into some other class of reg,
3564 search for an existing equivalent reg (same value now) in the right class.
3565 We can use it as long as we don't need to change its contents. */
3566 for (i
= 0; i
< n_reloads
; i
++)
3567 if (reload_reg_rtx
[i
] == 0
3568 && reload_in
[i
] != 0
3569 && GET_CODE (reload_in
[i
]) == REG
3570 && reload_out
[i
] == 0)
3573 = find_equiv_reg (reload_in
[i
], insn
, reload_reg_class
[i
], -1,
3574 static_reload_reg_p
, 0, reload_inmode
[i
]);
3575 /* Prevent generation of insn to load the value
3576 because the one we found already has the value. */
3577 if (reload_reg_rtx
[i
])
3578 reload_in
[i
] = reload_reg_rtx
[i
];
3582 /* Perhaps an output reload can be combined with another
3583 to reduce needs by one. */
3584 if (!goal_earlyclobber
)
3587 /* If we have a pair of reloads for parts of an address, they are reloading
3588 the same object, the operands themselves were not reloaded, and they
3589 are for two operands that are supposed to match, merge the reloads and
3590 change the type of the surviving reload to RELOAD_FOR_OPERAND_ADDRESS. */
3592 for (i
= 0; i
< n_reloads
; i
++)
3596 for (j
= i
+ 1; j
< n_reloads
; j
++)
3597 if ((reload_when_needed
[i
] == RELOAD_FOR_INPUT_ADDRESS
3598 || reload_when_needed
[i
] == RELOAD_FOR_OUTPUT_ADDRESS
)
3599 && (reload_when_needed
[j
] == RELOAD_FOR_INPUT_ADDRESS
3600 || reload_when_needed
[j
] == RELOAD_FOR_OUTPUT_ADDRESS
)
3601 && rtx_equal_p (reload_in
[i
], reload_in
[j
])
3602 && (operand_reloadnum
[reload_opnum
[i
]] < 0
3603 || reload_optional
[operand_reloadnum
[reload_opnum
[i
]]])
3604 && (operand_reloadnum
[reload_opnum
[j
]] < 0
3605 || reload_optional
[operand_reloadnum
[reload_opnum
[j
]]])
3606 && (goal_alternative_matches
[reload_opnum
[i
]] == reload_opnum
[j
]
3607 || (goal_alternative_matches
[reload_opnum
[j
]]
3608 == reload_opnum
[i
])))
3610 for (k
= 0; k
< n_replacements
; k
++)
3611 if (replacements
[k
].what
== j
)
3612 replacements
[k
].what
= i
;
3614 reload_when_needed
[i
] = RELOAD_FOR_OPERAND_ADDRESS
;
3619 /* Scan all the reloads and update their type.
3620 If a reload is for the address of an operand and we didn't reload
3621 that operand, change the type. Similarly, change the operand number
3622 of a reload when two operands match. If a reload is optional, treat it
3623 as though the operand isn't reloaded.
3625 ??? This latter case is somewhat odd because if we do the optional
3626 reload, it means the object is hanging around. Thus we need only
3627 do the address reload if the optional reload was NOT done.
3629 Change secondary reloads to be the address type of their operand, not
3632 If an operand's reload is now RELOAD_OTHER, change any
3633 RELOAD_FOR_INPUT_ADDRESS reloads of that operand to
3634 RELOAD_FOR_OTHER_ADDRESS. */
3636 for (i
= 0; i
< n_reloads
; i
++)
3638 if (reload_secondary_p
[i
]
3639 && reload_when_needed
[i
] == operand_type
[reload_opnum
[i
]])
3640 reload_when_needed
[i
] = address_type
[reload_opnum
[i
]];
3642 if ((reload_when_needed
[i
] == RELOAD_FOR_INPUT_ADDRESS
3643 || reload_when_needed
[i
] == RELOAD_FOR_OUTPUT_ADDRESS
)
3644 && (operand_reloadnum
[reload_opnum
[i
]] < 0
3645 || reload_optional
[operand_reloadnum
[reload_opnum
[i
]]]))
3647 /* If we have a secondary reload to go along with this reload,
3648 change its type to RELOAD_FOR_OPADDR_ADDR. */
3650 if (reload_when_needed
[i
] == RELOAD_FOR_INPUT_ADDRESS
3651 && reload_secondary_in_reload
[i
] != -1)
3653 int secondary_in_reload
= reload_secondary_in_reload
[i
];
3655 reload_when_needed
[secondary_in_reload
] =
3656 RELOAD_FOR_OPADDR_ADDR
;
3658 /* If there's a tertiary reload we have to change it also. */
3659 if (secondary_in_reload
> 0
3660 && reload_secondary_in_reload
[secondary_in_reload
] != -1)
3661 reload_when_needed
[reload_secondary_in_reload
[secondary_in_reload
]]
3662 = RELOAD_FOR_OPADDR_ADDR
;
3665 if (reload_when_needed
[i
] == RELOAD_FOR_OUTPUT_ADDRESS
3666 && reload_secondary_out_reload
[i
] != -1)
3668 int secondary_out_reload
= reload_secondary_out_reload
[i
];
3670 reload_when_needed
[secondary_out_reload
] =
3671 RELOAD_FOR_OPADDR_ADDR
;
3673 /* If there's a tertiary reload we have to change it also. */
3674 if (secondary_out_reload
3675 && reload_secondary_out_reload
[secondary_out_reload
] != -1)
3676 reload_when_needed
[reload_secondary_out_reload
[secondary_out_reload
]]
3677 = RELOAD_FOR_OPADDR_ADDR
;
3679 reload_when_needed
[i
] = RELOAD_FOR_OPERAND_ADDRESS
;
3682 if (reload_when_needed
[i
] == RELOAD_FOR_INPUT_ADDRESS
3683 && operand_reloadnum
[reload_opnum
[i
]] >= 0
3684 && (reload_when_needed
[operand_reloadnum
[reload_opnum
[i
]]]
3686 reload_when_needed
[i
] = RELOAD_FOR_OTHER_ADDRESS
;
3688 if (goal_alternative_matches
[reload_opnum
[i
]] >= 0)
3689 reload_opnum
[i
] = goal_alternative_matches
[reload_opnum
[i
]];
3692 /* See if we have any reloads that are now allowed to be merged
3693 because we've changed when the reload is needed to
3694 RELOAD_FOR_OPERAND_ADDRESS or RELOAD_FOR_OTHER_ADDRESS. Only
3695 check for the most common cases. */
3697 for (i
= 0; i
< n_reloads
; i
++)
3698 if (reload_in
[i
] != 0 && reload_out
[i
] == 0
3699 && (reload_when_needed
[i
] == RELOAD_FOR_OPERAND_ADDRESS
3700 || reload_when_needed
[i
] == RELOAD_FOR_OTHER_ADDRESS
))
3701 for (j
= 0; j
< n_reloads
; j
++)
3702 if (i
!= j
&& reload_in
[j
] != 0 && reload_out
[j
] == 0
3703 && reload_when_needed
[j
] == reload_when_needed
[i
]
3704 && MATCHES (reload_in
[i
], reload_in
[j
])
3705 && reload_reg_class
[i
] == reload_reg_class
[j
]
3706 && !reload_nocombine
[i
] && !reload_nocombine
[j
]
3707 && reload_reg_rtx
[i
] == reload_reg_rtx
[j
])
3709 reload_opnum
[i
] = MIN (reload_opnum
[i
], reload_opnum
[j
]);
3710 transfer_replacements (i
, j
);
3714 #else /* no REGISTER_CONSTRAINTS */
3716 int insn_code_number
;
3717 int goal_earlyclobber
= 0; /* Always 0, to make combine_reloads happen. */
3719 rtx body
= PATTERN (insn
);
3723 n_earlyclobbers
= 0;
3724 replace_reloads
= replace
;
3727 /* Find what kind of insn this is. NOPERANDS gets number of operands.
3728 Store the operand values in RECOG_OPERAND and the locations
3729 of the words in the insn that point to them in RECOG_OPERAND_LOC.
3730 Return if the insn needs no reload processing. */
3732 switch (GET_CODE (body
))
3743 noperands
= asm_noperands (body
);
3746 /* This insn is an `asm' with operands.
3747 First, find out how many operands, and allocate space. */
3749 insn_code_number
= -1;
3750 /* ??? This is a bug! ???
3751 Give up and delete this insn if it has too many operands. */
3752 if (noperands
> MAX_RECOG_OPERANDS
)
3755 /* Now get the operand values out of the insn. */
3757 decode_asm_operands (body
, recog_operand
, recog_operand_loc
,
3758 NULL_PTR
, NULL_PTR
);
3763 /* Ordinary insn: recognize it, allocate space for operands and
3764 constraints, and get them out via insn_extract. */
3766 insn_code_number
= recog_memoized (insn
);
3767 noperands
= insn_n_operands
[insn_code_number
];
3768 insn_extract (insn
);
3774 for (i
= 0; i
< noperands
; i
++)
3776 register RTX_CODE code
= GET_CODE (recog_operand
[i
]);
3777 int is_set_dest
= GET_CODE (body
) == SET
&& (i
== 0);
3779 if (insn_code_number
>= 0)
3780 if (insn_operand_address_p
[insn_code_number
][i
])
3781 find_reloads_address (VOIDmode
, NULL_PTR
,
3782 recog_operand
[i
], recog_operand_loc
[i
],
3783 i
, RELOAD_FOR_INPUT
, ind_levels
);
3785 /* In these cases, we can't tell if the operand is an input
3786 or an output, so be conservative. In practice it won't be
3790 find_reloads_address (GET_MODE (recog_operand
[i
]),
3791 recog_operand_loc
[i
],
3792 XEXP (recog_operand
[i
], 0),
3793 &XEXP (recog_operand
[i
], 0),
3794 i
, RELOAD_OTHER
, ind_levels
);
3796 recog_operand
[i
] = *recog_operand_loc
[i
]
3797 = find_reloads_toplev (recog_operand
[i
], i
, RELOAD_OTHER
,
3798 ind_levels
, is_set_dest
);
3801 register int regno
= REGNO (recog_operand
[i
]);
3802 if (reg_equiv_constant
[regno
] != 0 && !is_set_dest
)
3803 recog_operand
[i
] = *recog_operand_loc
[i
]
3804 = reg_equiv_constant
[regno
];
3805 #if 0 /* This might screw code in reload1.c to delete prior output-reload
3806 that feeds this insn. */
3807 if (reg_equiv_mem
[regno
] != 0)
3808 recog_operand
[i
] = *recog_operand_loc
[i
]
3809 = reg_equiv_mem
[regno
];
3814 /* Perhaps an output reload can be combined with another
3815 to reduce needs by one. */
3816 if (!goal_earlyclobber
)
3818 #endif /* no REGISTER_CONSTRAINTS */
3821 /* Return 1 if alternative number ALTNUM in constraint-string CONSTRAINT
3822 accepts a memory operand with constant address. */
3825 alternative_allows_memconst (constraint
, altnum
)
3830 /* Skip alternatives before the one requested. */
3833 while (*constraint
++ != ',');
3836 /* Scan the requested alternative for 'm' or 'o'.
3837 If one of them is present, this alternative accepts memory constants. */
3838 while ((c
= *constraint
++) && c
!= ',' && c
!= '#')
3839 if (c
== 'm' || c
== 'o')
3844 /* Scan X for memory references and scan the addresses for reloading.
3845 Also checks for references to "constant" regs that we want to eliminate
3846 and replaces them with the values they stand for.
3847 We may alter X destructively if it contains a reference to such.
3848 If X is just a constant reg, we return the equivalent value
3851 IND_LEVELS says how many levels of indirect addressing this machine
3854 OPNUM and TYPE identify the purpose of the reload.
3856 IS_SET_DEST is true if X is the destination of a SET, which is not
3857 appropriate to be replaced by a constant. */
3860 find_reloads_toplev (x
, opnum
, type
, ind_levels
, is_set_dest
)
3863 enum reload_type type
;
3867 register RTX_CODE code
= GET_CODE (x
);
3869 register char *fmt
= GET_RTX_FORMAT (code
);
3874 /* This code is duplicated for speed in find_reloads. */
3875 register int regno
= REGNO (x
);
3876 if (reg_equiv_constant
[regno
] != 0 && !is_set_dest
)
3877 x
= reg_equiv_constant
[regno
];
3879 /* This creates (subreg (mem...)) which would cause an unnecessary
3880 reload of the mem. */
3881 else if (reg_equiv_mem
[regno
] != 0)
3882 x
= reg_equiv_mem
[regno
];
3884 else if (reg_equiv_address
[regno
] != 0)
3886 /* If reg_equiv_address varies, it may be shared, so copy it. */
3887 /* We must rerun eliminate_regs, in case the elimination
3888 offsets have changed. */
3889 rtx addr
= XEXP (eliminate_regs (reg_equiv_memory_loc
[regno
], 0,
3893 if (rtx_varies_p (addr
))
3894 addr
= copy_rtx (addr
);
3896 x
= gen_rtx (MEM
, GET_MODE (x
), addr
);
3897 RTX_UNCHANGING_P (x
) = RTX_UNCHANGING_P (regno_reg_rtx
[regno
]);
3898 find_reloads_address (GET_MODE (x
), NULL_PTR
,
3900 &XEXP (x
, 0), opnum
, type
, ind_levels
);
3907 find_reloads_address (GET_MODE (x
), &tem
, XEXP (x
, 0), &XEXP (x
, 0),
3908 opnum
, type
, ind_levels
);
3912 if (code
== SUBREG
&& GET_CODE (SUBREG_REG (x
)) == REG
)
3914 /* Check for SUBREG containing a REG that's equivalent to a constant.
3915 If the constant has a known value, truncate it right now.
3916 Similarly if we are extracting a single-word of a multi-word
3917 constant. If the constant is symbolic, allow it to be substituted
3918 normally. push_reload will strip the subreg later. If the
3919 constant is VOIDmode, abort because we will lose the mode of
3920 the register (this should never happen because one of the cases
3921 above should handle it). */
3923 register int regno
= REGNO (SUBREG_REG (x
));
3926 if (subreg_lowpart_p (x
)
3927 && regno
>= FIRST_PSEUDO_REGISTER
&& reg_renumber
[regno
] < 0
3928 && reg_equiv_constant
[regno
] != 0
3929 && (tem
= gen_lowpart_common (GET_MODE (x
),
3930 reg_equiv_constant
[regno
])) != 0)
3933 if (GET_MODE_BITSIZE (GET_MODE (x
)) == BITS_PER_WORD
3934 && regno
>= FIRST_PSEUDO_REGISTER
&& reg_renumber
[regno
] < 0
3935 && reg_equiv_constant
[regno
] != 0
3936 && (tem
= operand_subword (reg_equiv_constant
[regno
],
3938 GET_MODE (SUBREG_REG (x
)))) != 0)
3941 if (regno
>= FIRST_PSEUDO_REGISTER
&& reg_renumber
[regno
] < 0
3942 && reg_equiv_constant
[regno
] != 0
3943 && GET_MODE (reg_equiv_constant
[regno
]) == VOIDmode
)
3946 /* If the subreg contains a reg that will be converted to a mem,
3947 convert the subreg to a narrower memref now.
3948 Otherwise, we would get (subreg (mem ...) ...),
3949 which would force reload of the mem.
3951 We also need to do this if there is an equivalent MEM that is
3952 not offsettable. In that case, alter_subreg would produce an
3953 invalid address on big-endian machines.
3955 For machines that extend byte loads, we must not reload using
3956 a wider mode if we have a paradoxical SUBREG. find_reloads will
3957 force a reload in that case. So we should not do anything here. */
3959 else if (regno
>= FIRST_PSEUDO_REGISTER
3960 #ifdef LOAD_EXTEND_OP
3961 && (GET_MODE_SIZE (GET_MODE (x
))
3962 <= GET_MODE_SIZE (GET_MODE (SUBREG_REG (x
))))
3964 && (reg_equiv_address
[regno
] != 0
3965 || (reg_equiv_mem
[regno
] != 0
3966 && (! strict_memory_address_p (GET_MODE (x
),
3967 XEXP (reg_equiv_mem
[regno
], 0))
3968 || ! offsettable_memref_p (reg_equiv_mem
[regno
])))))
3970 int offset
= SUBREG_WORD (x
) * UNITS_PER_WORD
;
3971 /* We must rerun eliminate_regs, in case the elimination
3972 offsets have changed. */
3973 rtx addr
= XEXP (eliminate_regs (reg_equiv_memory_loc
[regno
], 0,
3976 if (BYTES_BIG_ENDIAN
)
3979 size
= GET_MODE_SIZE (GET_MODE (SUBREG_REG (x
)));
3980 offset
+= MIN (size
, UNITS_PER_WORD
);
3981 size
= GET_MODE_SIZE (GET_MODE (x
));
3982 offset
-= MIN (size
, UNITS_PER_WORD
);
3984 addr
= plus_constant (addr
, offset
);
3985 x
= gen_rtx (MEM
, GET_MODE (x
), addr
);
3986 RTX_UNCHANGING_P (x
) = RTX_UNCHANGING_P (regno_reg_rtx
[regno
]);
3987 find_reloads_address (GET_MODE (x
), NULL_PTR
,
3989 &XEXP (x
, 0), opnum
, type
, ind_levels
);
3994 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
3997 XEXP (x
, i
) = find_reloads_toplev (XEXP (x
, i
), opnum
, type
,
3998 ind_levels
, is_set_dest
);
4003 /* Return a mem ref for the memory equivalent of reg REGNO.
4004 This mem ref is not shared with anything. */
4007 make_memloc (ad
, regno
)
4012 /* We must rerun eliminate_regs, in case the elimination
4013 offsets have changed. */
4014 rtx tem
= XEXP (eliminate_regs (reg_equiv_memory_loc
[regno
], 0, NULL_RTX
),
4017 #if 0 /* We cannot safely reuse a memloc made here;
4018 if the pseudo appears twice, and its mem needs a reload,
4019 it gets two separate reloads assigned, but it only
4020 gets substituted with the second of them;
4021 then it can get used before that reload reg gets loaded up. */
4022 for (i
= 0; i
< n_memlocs
; i
++)
4023 if (rtx_equal_p (tem
, XEXP (memlocs
[i
], 0)))
4027 /* If TEM might contain a pseudo, we must copy it to avoid
4028 modifying it when we do the substitution for the reload. */
4029 if (rtx_varies_p (tem
))
4030 tem
= copy_rtx (tem
);
4032 tem
= gen_rtx (MEM
, GET_MODE (ad
), tem
);
4033 RTX_UNCHANGING_P (tem
) = RTX_UNCHANGING_P (regno_reg_rtx
[regno
]);
4034 memlocs
[n_memlocs
++] = tem
;
4038 /* Record all reloads needed for handling memory address AD
4039 which appears in *LOC in a memory reference to mode MODE
4040 which itself is found in location *MEMREFLOC.
4041 Note that we take shortcuts assuming that no multi-reg machine mode
4042 occurs as part of an address.
4044 OPNUM and TYPE specify the purpose of this reload.
4046 IND_LEVELS says how many levels of indirect addressing this machine
4049 Value is nonzero if this address is reloaded or replaced as a whole.
4050 This is interesting to the caller if the address is an autoincrement.
4052 Note that there is no verification that the address will be valid after
4053 this routine does its work. Instead, we rely on the fact that the address
4054 was valid when reload started. So we need only undo things that reload
4055 could have broken. These are wrong register types, pseudos not allocated
4056 to a hard register, and frame pointer elimination. */
4059 find_reloads_address (mode
, memrefloc
, ad
, loc
, opnum
, type
, ind_levels
)
4060 enum machine_mode mode
;
4065 enum reload_type type
;
4071 /* If the address is a register, see if it is a legitimate address and
4072 reload if not. We first handle the cases where we need not reload
4073 or where we must reload in a non-standard way. */
4075 if (GET_CODE (ad
) == REG
)
4079 if (reg_equiv_constant
[regno
] != 0
4080 && strict_memory_address_p (mode
, reg_equiv_constant
[regno
]))
4082 *loc
= ad
= reg_equiv_constant
[regno
];
4086 else if (reg_equiv_address
[regno
] != 0)
4088 tem
= make_memloc (ad
, regno
);
4089 find_reloads_address (GET_MODE (tem
), NULL_PTR
, XEXP (tem
, 0),
4090 &XEXP (tem
, 0), opnum
, type
, ind_levels
);
4091 push_reload (tem
, NULL_RTX
, loc
, NULL_PTR
, BASE_REG_CLASS
,
4092 GET_MODE (ad
), VOIDmode
, 0, 0,
4097 /* We can avoid a reload if the register's equivalent memory expression
4098 is valid as an indirect memory address.
4099 But not all addresses are valid in a mem used as an indirect address:
4100 only reg or reg+constant. */
4102 else if (reg_equiv_mem
[regno
] != 0 && ind_levels
> 0
4103 && strict_memory_address_p (mode
, reg_equiv_mem
[regno
])
4104 && (GET_CODE (XEXP (reg_equiv_mem
[regno
], 0)) == REG
4105 || (GET_CODE (XEXP (reg_equiv_mem
[regno
], 0)) == PLUS
4106 && GET_CODE (XEXP (XEXP (reg_equiv_mem
[regno
], 0), 0)) == REG
4107 && CONSTANT_P (XEXP (XEXP (reg_equiv_mem
[regno
], 0), 1)))))
4110 /* The only remaining case where we can avoid a reload is if this is a
4111 hard register that is valid as a base register and which is not the
4112 subject of a CLOBBER in this insn. */
4114 else if (regno
< FIRST_PSEUDO_REGISTER
&& REGNO_OK_FOR_BASE_P (regno
)
4115 && ! regno_clobbered_p (regno
, this_insn
))
4118 /* If we do not have one of the cases above, we must do the reload. */
4119 push_reload (ad
, NULL_RTX
, loc
, NULL_PTR
, BASE_REG_CLASS
,
4120 GET_MODE (ad
), VOIDmode
, 0, 0, opnum
, type
);
4124 if (strict_memory_address_p (mode
, ad
))
4126 /* The address appears valid, so reloads are not needed.
4127 But the address may contain an eliminable register.
4128 This can happen because a machine with indirect addressing
4129 may consider a pseudo register by itself a valid address even when
4130 it has failed to get a hard reg.
4131 So do a tree-walk to find and eliminate all such regs. */
4133 /* But first quickly dispose of a common case. */
4134 if (GET_CODE (ad
) == PLUS
4135 && GET_CODE (XEXP (ad
, 1)) == CONST_INT
4136 && GET_CODE (XEXP (ad
, 0)) == REG
4137 && reg_equiv_constant
[REGNO (XEXP (ad
, 0))] == 0)
4140 subst_reg_equivs_changed
= 0;
4141 *loc
= subst_reg_equivs (ad
);
4143 if (! subst_reg_equivs_changed
)
4146 /* Check result for validity after substitution. */
4147 if (strict_memory_address_p (mode
, ad
))
4151 /* The address is not valid. We have to figure out why. One possibility
4152 is that it is itself a MEM. This can happen when the frame pointer is
4153 being eliminated, a pseudo is not allocated to a hard register, and the
4154 offset between the frame and stack pointers is not its initial value.
4155 In that case the pseudo will have been replaced by a MEM referring to
4156 the stack pointer. */
4157 if (GET_CODE (ad
) == MEM
)
4159 /* First ensure that the address in this MEM is valid. Then, unless
4160 indirect addresses are valid, reload the MEM into a register. */
4162 find_reloads_address (GET_MODE (ad
), &tem
, XEXP (ad
, 0), &XEXP (ad
, 0),
4163 opnum
, type
, ind_levels
== 0 ? 0 : ind_levels
- 1);
4165 /* If tem was changed, then we must create a new memory reference to
4166 hold it and store it back into memrefloc. */
4167 if (tem
!= ad
&& memrefloc
)
4169 *memrefloc
= copy_rtx (*memrefloc
);
4170 copy_replacements (tem
, XEXP (*memrefloc
, 0));
4171 loc
= &XEXP (*memrefloc
, 0);
4174 /* Check similar cases as for indirect addresses as above except
4175 that we can allow pseudos and a MEM since they should have been
4176 taken care of above. */
4179 || (GET_CODE (XEXP (tem
, 0)) == SYMBOL_REF
&& ! indirect_symref_ok
)
4180 || GET_CODE (XEXP (tem
, 0)) == MEM
4181 || ! (GET_CODE (XEXP (tem
, 0)) == REG
4182 || (GET_CODE (XEXP (tem
, 0)) == PLUS
4183 && GET_CODE (XEXP (XEXP (tem
, 0), 0)) == REG
4184 && GET_CODE (XEXP (XEXP (tem
, 0), 1)) == CONST_INT
)))
4186 /* Must use TEM here, not AD, since it is the one that will
4187 have any subexpressions reloaded, if needed. */
4188 push_reload (tem
, NULL_RTX
, loc
, NULL_PTR
,
4189 BASE_REG_CLASS
, GET_MODE (tem
), VOIDmode
, 0,
4197 /* If we have address of a stack slot but it's not valid
4198 (displacement is too large), compute the sum in a register. */
4199 else if (GET_CODE (ad
) == PLUS
4200 && (XEXP (ad
, 0) == frame_pointer_rtx
4201 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
4202 || XEXP (ad
, 0) == hard_frame_pointer_rtx
4204 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
4205 || XEXP (ad
, 0) == arg_pointer_rtx
4207 || XEXP (ad
, 0) == stack_pointer_rtx
)
4208 && GET_CODE (XEXP (ad
, 1)) == CONST_INT
)
4210 /* Unshare the MEM rtx so we can safely alter it. */
4213 *memrefloc
= copy_rtx (*memrefloc
);
4214 loc
= &XEXP (*memrefloc
, 0);
4216 if (double_reg_address_ok
)
4218 /* Unshare the sum as well. */
4219 *loc
= ad
= copy_rtx (ad
);
4220 /* Reload the displacement into an index reg.
4221 We assume the frame pointer or arg pointer is a base reg. */
4222 find_reloads_address_part (XEXP (ad
, 1), &XEXP (ad
, 1),
4223 INDEX_REG_CLASS
, GET_MODE (ad
), opnum
,
4228 /* If the sum of two regs is not necessarily valid,
4229 reload the sum into a base reg.
4230 That will at least work. */
4231 find_reloads_address_part (ad
, loc
, BASE_REG_CLASS
, Pmode
,
4232 opnum
, type
, ind_levels
);
4237 /* If we have an indexed stack slot, there are three possible reasons why
4238 it might be invalid: The index might need to be reloaded, the address
4239 might have been made by frame pointer elimination and hence have a
4240 constant out of range, or both reasons might apply.
4242 We can easily check for an index needing reload, but even if that is the
4243 case, we might also have an invalid constant. To avoid making the
4244 conservative assumption and requiring two reloads, we see if this address
4245 is valid when not interpreted strictly. If it is, the only problem is
4246 that the index needs a reload and find_reloads_address_1 will take care
4249 There is still a case when we might generate an extra reload,
4250 however. In certain cases eliminate_regs will return a MEM for a REG
4251 (see the code there for details). In those cases, memory_address_p
4252 applied to our address will return 0 so we will think that our offset
4253 must be too large. But it might indeed be valid and the only problem
4254 is that a MEM is present where a REG should be. This case should be
4255 very rare and there doesn't seem to be any way to avoid it.
4257 If we decide to do something here, it must be that
4258 `double_reg_address_ok' is true and that this address rtl was made by
4259 eliminate_regs. We generate a reload of the fp/sp/ap + constant and
4260 rework the sum so that the reload register will be added to the index.
4261 This is safe because we know the address isn't shared.
4263 We check for fp/ap/sp as both the first and second operand of the
4266 else if (GET_CODE (ad
) == PLUS
&& GET_CODE (XEXP (ad
, 1)) == CONST_INT
4267 && GET_CODE (XEXP (ad
, 0)) == PLUS
4268 && (XEXP (XEXP (ad
, 0), 0) == frame_pointer_rtx
4269 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
4270 || XEXP (XEXP (ad
, 0), 0) == hard_frame_pointer_rtx
4272 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
4273 || XEXP (XEXP (ad
, 0), 0) == arg_pointer_rtx
4275 || XEXP (XEXP (ad
, 0), 0) == stack_pointer_rtx
)
4276 && ! memory_address_p (mode
, ad
))
4278 *loc
= ad
= gen_rtx (PLUS
, GET_MODE (ad
),
4279 plus_constant (XEXP (XEXP (ad
, 0), 0),
4280 INTVAL (XEXP (ad
, 1))),
4281 XEXP (XEXP (ad
, 0), 1));
4282 find_reloads_address_part (XEXP (ad
, 0), &XEXP (ad
, 0), BASE_REG_CLASS
,
4283 GET_MODE (ad
), opnum
, type
, ind_levels
);
4284 find_reloads_address_1 (XEXP (ad
, 1), 1, &XEXP (ad
, 1), opnum
, type
, 0);
4289 else if (GET_CODE (ad
) == PLUS
&& GET_CODE (XEXP (ad
, 1)) == CONST_INT
4290 && GET_CODE (XEXP (ad
, 0)) == PLUS
4291 && (XEXP (XEXP (ad
, 0), 1) == frame_pointer_rtx
4292 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
4293 || XEXP (XEXP (ad
, 0), 1) == hard_frame_pointer_rtx
4295 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
4296 || XEXP (XEXP (ad
, 0), 1) == arg_pointer_rtx
4298 || XEXP (XEXP (ad
, 0), 1) == stack_pointer_rtx
)
4299 && ! memory_address_p (mode
, ad
))
4301 *loc
= ad
= gen_rtx (PLUS
, GET_MODE (ad
),
4302 XEXP (XEXP (ad
, 0), 0),
4303 plus_constant (XEXP (XEXP (ad
, 0), 1),
4304 INTVAL (XEXP (ad
, 1))));
4305 find_reloads_address_part (XEXP (ad
, 1), &XEXP (ad
, 1), BASE_REG_CLASS
,
4306 GET_MODE (ad
), opnum
, type
, ind_levels
);
4307 find_reloads_address_1 (XEXP (ad
, 0), 1, &XEXP (ad
, 0), opnum
, type
, 0);
4312 /* See if address becomes valid when an eliminable register
4313 in a sum is replaced. */
4316 if (GET_CODE (ad
) == PLUS
)
4317 tem
= subst_indexed_address (ad
);
4318 if (tem
!= ad
&& strict_memory_address_p (mode
, tem
))
4320 /* Ok, we win that way. Replace any additional eliminable
4323 subst_reg_equivs_changed
= 0;
4324 tem
= subst_reg_equivs (tem
);
4326 /* Make sure that didn't make the address invalid again. */
4328 if (! subst_reg_equivs_changed
|| strict_memory_address_p (mode
, tem
))
4335 /* If constants aren't valid addresses, reload the constant address
4337 if (CONSTANT_P (ad
) && ! strict_memory_address_p (mode
, ad
))
4339 /* If AD is in address in the constant pool, the MEM rtx may be shared.
4340 Unshare it so we can safely alter it. */
4341 if (memrefloc
&& GET_CODE (ad
) == SYMBOL_REF
4342 && CONSTANT_POOL_ADDRESS_P (ad
))
4344 *memrefloc
= copy_rtx (*memrefloc
);
4345 loc
= &XEXP (*memrefloc
, 0);
4348 find_reloads_address_part (ad
, loc
, BASE_REG_CLASS
, Pmode
, opnum
, type
,
4353 return find_reloads_address_1 (ad
, 0, loc
, opnum
, type
, ind_levels
);
4356 /* Find all pseudo regs appearing in AD
4357 that are eliminable in favor of equivalent values
4358 and do not have hard regs; replace them by their equivalents. */
4361 subst_reg_equivs (ad
)
4364 register RTX_CODE code
= GET_CODE (ad
);
4382 register int regno
= REGNO (ad
);
4384 if (reg_equiv_constant
[regno
] != 0)
4386 subst_reg_equivs_changed
= 1;
4387 return reg_equiv_constant
[regno
];
4393 /* Quickly dispose of a common case. */
4394 if (XEXP (ad
, 0) == frame_pointer_rtx
4395 && GET_CODE (XEXP (ad
, 1)) == CONST_INT
)
4399 fmt
= GET_RTX_FORMAT (code
);
4400 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
4402 XEXP (ad
, i
) = subst_reg_equivs (XEXP (ad
, i
));
4406 /* Compute the sum of X and Y, making canonicalizations assumed in an
4407 address, namely: sum constant integers, surround the sum of two
4408 constants with a CONST, put the constant as the second operand, and
4409 group the constant on the outermost sum.
4411 This routine assumes both inputs are already in canonical form. */
4418 enum machine_mode mode
= GET_MODE (x
);
4420 if (mode
== VOIDmode
)
4421 mode
= GET_MODE (y
);
4423 if (mode
== VOIDmode
)
4426 if (GET_CODE (x
) == CONST_INT
)
4427 return plus_constant (y
, INTVAL (x
));
4428 else if (GET_CODE (y
) == CONST_INT
)
4429 return plus_constant (x
, INTVAL (y
));
4430 else if (CONSTANT_P (x
))
4431 tem
= x
, x
= y
, y
= tem
;
4433 if (GET_CODE (x
) == PLUS
&& CONSTANT_P (XEXP (x
, 1)))
4434 return form_sum (XEXP (x
, 0), form_sum (XEXP (x
, 1), y
));
4436 /* Note that if the operands of Y are specified in the opposite
4437 order in the recursive calls below, infinite recursion will occur. */
4438 if (GET_CODE (y
) == PLUS
&& CONSTANT_P (XEXP (y
, 1)))
4439 return form_sum (form_sum (x
, XEXP (y
, 0)), XEXP (y
, 1));
4441 /* If both constant, encapsulate sum. Otherwise, just form sum. A
4442 constant will have been placed second. */
4443 if (CONSTANT_P (x
) && CONSTANT_P (y
))
4445 if (GET_CODE (x
) == CONST
)
4447 if (GET_CODE (y
) == CONST
)
4450 return gen_rtx (CONST
, VOIDmode
, gen_rtx (PLUS
, mode
, x
, y
));
4453 return gen_rtx (PLUS
, mode
, x
, y
);
4456 /* If ADDR is a sum containing a pseudo register that should be
4457 replaced with a constant (from reg_equiv_constant),
4458 return the result of doing so, and also apply the associative
4459 law so that the result is more likely to be a valid address.
4460 (But it is not guaranteed to be one.)
4462 Note that at most one register is replaced, even if more are
4463 replaceable. Also, we try to put the result into a canonical form
4464 so it is more likely to be a valid address.
4466 In all other cases, return ADDR. */
4469 subst_indexed_address (addr
)
4472 rtx op0
= 0, op1
= 0, op2
= 0;
4476 if (GET_CODE (addr
) == PLUS
)
4478 /* Try to find a register to replace. */
4479 op0
= XEXP (addr
, 0), op1
= XEXP (addr
, 1), op2
= 0;
4480 if (GET_CODE (op0
) == REG
4481 && (regno
= REGNO (op0
)) >= FIRST_PSEUDO_REGISTER
4482 && reg_renumber
[regno
] < 0
4483 && reg_equiv_constant
[regno
] != 0)
4484 op0
= reg_equiv_constant
[regno
];
4485 else if (GET_CODE (op1
) == REG
4486 && (regno
= REGNO (op1
)) >= FIRST_PSEUDO_REGISTER
4487 && reg_renumber
[regno
] < 0
4488 && reg_equiv_constant
[regno
] != 0)
4489 op1
= reg_equiv_constant
[regno
];
4490 else if (GET_CODE (op0
) == PLUS
4491 && (tem
= subst_indexed_address (op0
)) != op0
)
4493 else if (GET_CODE (op1
) == PLUS
4494 && (tem
= subst_indexed_address (op1
)) != op1
)
4499 /* Pick out up to three things to add. */
4500 if (GET_CODE (op1
) == PLUS
)
4501 op2
= XEXP (op1
, 1), op1
= XEXP (op1
, 0);
4502 else if (GET_CODE (op0
) == PLUS
)
4503 op2
= op1
, op1
= XEXP (op0
, 1), op0
= XEXP (op0
, 0);
4505 /* Compute the sum. */
4507 op1
= form_sum (op1
, op2
);
4509 op0
= form_sum (op0
, op1
);
4516 /* Record the pseudo registers we must reload into hard registers
4517 in a subexpression of a would-be memory address, X.
4518 (This function is not called if the address we find is strictly valid.)
4519 CONTEXT = 1 means we are considering regs as index regs,
4520 = 0 means we are considering them as base regs.
4522 OPNUM and TYPE specify the purpose of any reloads made.
4524 IND_LEVELS says how many levels of indirect addressing are
4525 supported at this point in the address.
4527 We return nonzero if X, as a whole, is reloaded or replaced. */
4529 /* Note that we take shortcuts assuming that no multi-reg machine mode
4530 occurs as part of an address.
4531 Also, this is not fully machine-customizable; it works for machines
4532 such as vaxes and 68000's and 32000's, but other possible machines
4533 could have addressing modes that this does not handle right. */
4536 find_reloads_address_1 (x
, context
, loc
, opnum
, type
, ind_levels
)
4541 enum reload_type type
;
4544 register RTX_CODE code
= GET_CODE (x
);
4550 register rtx orig_op0
= XEXP (x
, 0);
4551 register rtx orig_op1
= XEXP (x
, 1);
4552 register RTX_CODE code0
= GET_CODE (orig_op0
);
4553 register RTX_CODE code1
= GET_CODE (orig_op1
);
4554 register rtx op0
= orig_op0
;
4555 register rtx op1
= orig_op1
;
4557 if (GET_CODE (op0
) == SUBREG
)
4559 op0
= SUBREG_REG (op0
);
4560 code0
= GET_CODE (op0
);
4563 if (GET_CODE (op1
) == SUBREG
)
4565 op1
= SUBREG_REG (op1
);
4566 code1
= GET_CODE (op1
);
4569 if (code0
== MULT
|| code0
== SIGN_EXTEND
|| code0
== TRUNCATE
4570 || code0
== ZERO_EXTEND
|| code1
== MEM
)
4572 find_reloads_address_1 (orig_op0
, 1, &XEXP (x
, 0), opnum
, type
,
4574 find_reloads_address_1 (orig_op1
, 0, &XEXP (x
, 1), opnum
, type
,
4578 else if (code1
== MULT
|| code1
== SIGN_EXTEND
|| code1
== TRUNCATE
4579 || code1
== ZERO_EXTEND
|| code0
== MEM
)
4581 find_reloads_address_1 (orig_op0
, 0, &XEXP (x
, 0), opnum
, type
,
4583 find_reloads_address_1 (orig_op1
, 1, &XEXP (x
, 1), opnum
, type
,
4587 else if (code0
== CONST_INT
|| code0
== CONST
4588 || code0
== SYMBOL_REF
|| code0
== LABEL_REF
)
4589 find_reloads_address_1 (orig_op1
, 0, &XEXP (x
, 1), opnum
, type
,
4592 else if (code1
== CONST_INT
|| code1
== CONST
4593 || code1
== SYMBOL_REF
|| code1
== LABEL_REF
)
4594 find_reloads_address_1 (orig_op0
, 0, &XEXP (x
, 0), opnum
, type
,
4597 else if (code0
== REG
&& code1
== REG
)
4599 if (REG_OK_FOR_INDEX_P (op0
)
4600 && REG_OK_FOR_BASE_P (op1
))
4602 else if (REG_OK_FOR_INDEX_P (op1
)
4603 && REG_OK_FOR_BASE_P (op0
))
4605 else if (REG_OK_FOR_BASE_P (op1
))
4606 find_reloads_address_1 (orig_op0
, 1, &XEXP (x
, 0), opnum
, type
,
4608 else if (REG_OK_FOR_BASE_P (op0
))
4609 find_reloads_address_1 (orig_op1
, 1, &XEXP (x
, 1), opnum
, type
,
4611 else if (REG_OK_FOR_INDEX_P (op1
))
4612 find_reloads_address_1 (orig_op0
, 0, &XEXP (x
, 0), opnum
, type
,
4614 else if (REG_OK_FOR_INDEX_P (op0
))
4615 find_reloads_address_1 (orig_op1
, 0, &XEXP (x
, 1), opnum
, type
,
4619 find_reloads_address_1 (orig_op0
, 1, &XEXP (x
, 0), opnum
, type
,
4621 find_reloads_address_1 (orig_op1
, 0, &XEXP (x
, 1), opnum
, type
,
4626 else if (code0
== REG
)
4628 find_reloads_address_1 (orig_op0
, 1, &XEXP (x
, 0), opnum
, type
,
4630 find_reloads_address_1 (orig_op1
, 0, &XEXP (x
, 1), opnum
, type
,
4634 else if (code1
== REG
)
4636 find_reloads_address_1 (orig_op1
, 1, &XEXP (x
, 1), opnum
, type
,
4638 find_reloads_address_1 (orig_op0
, 0, &XEXP (x
, 0), opnum
, type
,
4649 if (GET_CODE (XEXP (x
, 0)) == REG
)
4651 register int regno
= REGNO (XEXP (x
, 0));
4655 /* A register that is incremented cannot be constant! */
4656 if (regno
>= FIRST_PSEUDO_REGISTER
4657 && reg_equiv_constant
[regno
] != 0)
4660 /* Handle a register that is equivalent to a memory location
4661 which cannot be addressed directly. */
4662 if (reg_equiv_address
[regno
] != 0)
4664 rtx tem
= make_memloc (XEXP (x
, 0), regno
);
4665 /* First reload the memory location's address. */
4666 find_reloads_address (GET_MODE (tem
), 0, XEXP (tem
, 0),
4667 &XEXP (tem
, 0), opnum
, type
, ind_levels
);
4668 /* Put this inside a new increment-expression. */
4669 x
= gen_rtx (GET_CODE (x
), GET_MODE (x
), tem
);
4670 /* Proceed to reload that, as if it contained a register. */
4673 /* If we have a hard register that is ok as an index,
4674 don't make a reload. If an autoincrement of a nice register
4675 isn't "valid", it must be that no autoincrement is "valid".
4676 If that is true and something made an autoincrement anyway,
4677 this must be a special context where one is allowed.
4678 (For example, a "push" instruction.)
4679 We can't improve this address, so leave it alone. */
4681 /* Otherwise, reload the autoincrement into a suitable hard reg
4682 and record how much to increment by. */
4684 if (reg_renumber
[regno
] >= 0)
4685 regno
= reg_renumber
[regno
];
4686 if ((regno
>= FIRST_PSEUDO_REGISTER
4687 || !(context
? REGNO_OK_FOR_INDEX_P (regno
)
4688 : REGNO_OK_FOR_BASE_P (regno
))))
4693 = push_reload (x
, NULL_RTX
, loc
, NULL_PTR
,
4694 context
? INDEX_REG_CLASS
: BASE_REG_CLASS
,
4695 GET_MODE (x
), GET_MODE (x
), VOIDmode
, 0,
4697 reload_inc
[reloadnum
]
4698 = find_inc_amount (PATTERN (this_insn
), XEXP (x_orig
, 0));
4703 /* Update the REG_INC notes. */
4705 for (link
= REG_NOTES (this_insn
);
4706 link
; link
= XEXP (link
, 1))
4707 if (REG_NOTE_KIND (link
) == REG_INC
4708 && REGNO (XEXP (link
, 0)) == REGNO (XEXP (x_orig
, 0)))
4709 push_replacement (&XEXP (link
, 0), reloadnum
, VOIDmode
);
4715 else if (GET_CODE (XEXP (x
, 0)) == MEM
)
4717 /* This is probably the result of a substitution, by eliminate_regs,
4718 of an equivalent address for a pseudo that was not allocated to a
4719 hard register. Verify that the specified address is valid and
4720 reload it into a register. */
4721 rtx tem
= XEXP (x
, 0);
4725 /* Since we know we are going to reload this item, don't decrement
4726 for the indirection level.
4728 Note that this is actually conservative: it would be slightly
4729 more efficient to use the value of SPILL_INDIRECT_LEVELS from
4731 find_reloads_address (GET_MODE (x
), &XEXP (x
, 0),
4732 XEXP (XEXP (x
, 0), 0), &XEXP (XEXP (x
, 0), 0),
4733 opnum
, type
, ind_levels
);
4735 reloadnum
= push_reload (x
, NULL_RTX
, loc
, NULL_PTR
,
4736 context
? INDEX_REG_CLASS
: BASE_REG_CLASS
,
4737 GET_MODE (x
), VOIDmode
, 0, 0, opnum
, type
);
4738 reload_inc
[reloadnum
]
4739 = find_inc_amount (PATTERN (this_insn
), XEXP (x
, 0));
4741 link
= FIND_REG_INC_NOTE (this_insn
, tem
);
4743 push_replacement (&XEXP (link
, 0), reloadnum
, VOIDmode
);
4750 /* This is probably the result of a substitution, by eliminate_regs, of
4751 an equivalent address for a pseudo that was not allocated to a hard
4752 register. Verify that the specified address is valid and reload it
4755 Since we know we are going to reload this item, don't decrement for
4756 the indirection level.
4758 Note that this is actually conservative: it would be slightly more
4759 efficient to use the value of SPILL_INDIRECT_LEVELS from
4762 find_reloads_address (GET_MODE (x
), loc
, XEXP (x
, 0), &XEXP (x
, 0),
4763 opnum
, type
, ind_levels
);
4764 push_reload (*loc
, NULL_RTX
, loc
, NULL_PTR
,
4765 context
? INDEX_REG_CLASS
: BASE_REG_CLASS
,
4766 GET_MODE (x
), VOIDmode
, 0, 0, opnum
, type
);
4771 register int regno
= REGNO (x
);
4773 if (reg_equiv_constant
[regno
] != 0)
4775 find_reloads_address_part (reg_equiv_constant
[regno
], loc
,
4776 (context
? INDEX_REG_CLASS
4778 GET_MODE (x
), opnum
, type
, ind_levels
);
4782 #if 0 /* This might screw code in reload1.c to delete prior output-reload
4783 that feeds this insn. */
4784 if (reg_equiv_mem
[regno
] != 0)
4786 push_reload (reg_equiv_mem
[regno
], NULL_RTX
, loc
, NULL_PTR
,
4787 context
? INDEX_REG_CLASS
: BASE_REG_CLASS
,
4788 GET_MODE (x
), VOIDmode
, 0, 0, opnum
, type
);
4793 if (reg_equiv_address
[regno
] != 0)
4795 x
= make_memloc (x
, regno
);
4796 find_reloads_address (GET_MODE (x
), 0, XEXP (x
, 0), &XEXP (x
, 0),
4797 opnum
, type
, ind_levels
);
4800 if (reg_renumber
[regno
] >= 0)
4801 regno
= reg_renumber
[regno
];
4803 if ((regno
>= FIRST_PSEUDO_REGISTER
4804 || !(context
? REGNO_OK_FOR_INDEX_P (regno
)
4805 : REGNO_OK_FOR_BASE_P (regno
))))
4807 push_reload (x
, NULL_RTX
, loc
, NULL_PTR
,
4808 context
? INDEX_REG_CLASS
: BASE_REG_CLASS
,
4809 GET_MODE (x
), VOIDmode
, 0, 0, opnum
, type
);
4813 /* If a register appearing in an address is the subject of a CLOBBER
4814 in this insn, reload it into some other register to be safe.
4815 The CLOBBER is supposed to make the register unavailable
4816 from before this insn to after it. */
4817 if (regno_clobbered_p (regno
, this_insn
))
4819 push_reload (x
, NULL_RTX
, loc
, NULL_PTR
,
4820 context
? INDEX_REG_CLASS
: BASE_REG_CLASS
,
4821 GET_MODE (x
), VOIDmode
, 0, 0, opnum
, type
);
4828 /* If this is a SUBREG of a hard register and the resulting register is
4829 of the wrong class, reload the whole SUBREG. This avoids needless
4830 copies if SUBREG_REG is multi-word. */
4831 if (GET_CODE (SUBREG_REG (x
)) == REG
4832 && REGNO (SUBREG_REG (x
)) < FIRST_PSEUDO_REGISTER
)
4834 int regno
= REGNO (SUBREG_REG (x
)) + SUBREG_WORD (x
);
4836 if (! (context
? REGNO_OK_FOR_INDEX_P (regno
)
4837 : REGNO_OK_FOR_BASE_P (regno
)))
4839 push_reload (x
, NULL_RTX
, loc
, NULL_PTR
,
4840 context
? INDEX_REG_CLASS
: BASE_REG_CLASS
,
4841 GET_MODE (x
), VOIDmode
, 0, 0, opnum
, type
);
4849 register char *fmt
= GET_RTX_FORMAT (code
);
4852 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
4855 find_reloads_address_1 (XEXP (x
, i
), context
, &XEXP (x
, i
),
4856 opnum
, type
, ind_levels
);
4863 /* X, which is found at *LOC, is a part of an address that needs to be
4864 reloaded into a register of class CLASS. If X is a constant, or if
4865 X is a PLUS that contains a constant, check that the constant is a
4866 legitimate operand and that we are supposed to be able to load
4867 it into the register.
4869 If not, force the constant into memory and reload the MEM instead.
4871 MODE is the mode to use, in case X is an integer constant.
4873 OPNUM and TYPE describe the purpose of any reloads made.
4875 IND_LEVELS says how many levels of indirect addressing this machine
4879 find_reloads_address_part (x
, loc
, class, mode
, opnum
, type
, ind_levels
)
4882 enum reg_class
class;
4883 enum machine_mode mode
;
4885 enum reload_type type
;
4889 && (! LEGITIMATE_CONSTANT_P (x
)
4890 || PREFERRED_RELOAD_CLASS (x
, class) == NO_REGS
))
4892 rtx tem
= x
= force_const_mem (mode
, x
);
4893 find_reloads_address (mode
, &tem
, XEXP (tem
, 0), &XEXP (tem
, 0),
4894 opnum
, type
, ind_levels
);
4897 else if (GET_CODE (x
) == PLUS
4898 && CONSTANT_P (XEXP (x
, 1))
4899 && (! LEGITIMATE_CONSTANT_P (XEXP (x
, 1))
4900 || PREFERRED_RELOAD_CLASS (XEXP (x
, 1), class) == NO_REGS
))
4902 rtx tem
= force_const_mem (GET_MODE (x
), XEXP (x
, 1));
4904 x
= gen_rtx (PLUS
, GET_MODE (x
), XEXP (x
, 0), tem
);
4905 find_reloads_address (mode
, &tem
, XEXP (tem
, 0), &XEXP (tem
, 0),
4906 opnum
, type
, ind_levels
);
4909 push_reload (x
, NULL_RTX
, loc
, NULL_PTR
, class,
4910 mode
, VOIDmode
, 0, 0, opnum
, type
);
4913 /* Substitute into the current INSN the registers into which we have reloaded
4914 the things that need reloading. The array `replacements'
4915 says contains the locations of all pointers that must be changed
4916 and says what to replace them with.
4918 Return the rtx that X translates into; usually X, but modified. */
4925 for (i
= 0; i
< n_replacements
; i
++)
4927 register struct replacement
*r
= &replacements
[i
];
4928 register rtx reloadreg
= reload_reg_rtx
[r
->what
];
4931 /* Encapsulate RELOADREG so its machine mode matches what
4932 used to be there. Note that gen_lowpart_common will
4933 do the wrong thing if RELOADREG is multi-word. RELOADREG
4934 will always be a REG here. */
4935 if (GET_MODE (reloadreg
) != r
->mode
&& r
->mode
!= VOIDmode
)
4936 reloadreg
= gen_rtx (REG
, r
->mode
, REGNO (reloadreg
));
4938 /* If we are putting this into a SUBREG and RELOADREG is a
4939 SUBREG, we would be making nested SUBREGs, so we have to fix
4940 this up. Note that r->where == &SUBREG_REG (*r->subreg_loc). */
4942 if (r
->subreg_loc
!= 0 && GET_CODE (reloadreg
) == SUBREG
)
4944 if (GET_MODE (*r
->subreg_loc
)
4945 == GET_MODE (SUBREG_REG (reloadreg
)))
4946 *r
->subreg_loc
= SUBREG_REG (reloadreg
);
4949 *r
->where
= SUBREG_REG (reloadreg
);
4950 SUBREG_WORD (*r
->subreg_loc
) += SUBREG_WORD (reloadreg
);
4954 *r
->where
= reloadreg
;
4956 /* If reload got no reg and isn't optional, something's wrong. */
4957 else if (! reload_optional
[r
->what
])
4962 /* Make a copy of any replacements being done into X and move those copies
4963 to locations in Y, a copy of X. We only look at the highest level of
4967 copy_replacements (x
, y
)
4972 enum rtx_code code
= GET_CODE (x
);
4973 char *fmt
= GET_RTX_FORMAT (code
);
4974 struct replacement
*r
;
4976 /* We can't support X being a SUBREG because we might then need to know its
4977 location if something inside it was replaced. */
4981 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
4983 for (j
= 0; j
< n_replacements
; j
++)
4985 if (replacements
[j
].subreg_loc
== &XEXP (x
, i
))
4987 r
= &replacements
[n_replacements
++];
4988 r
->where
= replacements
[j
].where
;
4989 r
->subreg_loc
= &XEXP (y
, i
);
4990 r
->what
= replacements
[j
].what
;
4991 r
->mode
= replacements
[j
].mode
;
4993 else if (replacements
[j
].where
== &XEXP (x
, i
))
4995 r
= &replacements
[n_replacements
++];
4996 r
->where
= &XEXP (y
, i
);
4998 r
->what
= replacements
[j
].what
;
4999 r
->mode
= replacements
[j
].mode
;
5004 /* If LOC was scheduled to be replaced by something, return the replacement.
5005 Otherwise, return *LOC. */
5008 find_replacement (loc
)
5011 struct replacement
*r
;
5013 for (r
= &replacements
[0]; r
< &replacements
[n_replacements
]; r
++)
5015 rtx reloadreg
= reload_reg_rtx
[r
->what
];
5017 if (reloadreg
&& r
->where
== loc
)
5019 if (r
->mode
!= VOIDmode
&& GET_MODE (reloadreg
) != r
->mode
)
5020 reloadreg
= gen_rtx (REG
, r
->mode
, REGNO (reloadreg
));
5024 else if (reloadreg
&& r
->subreg_loc
== loc
)
5026 /* RELOADREG must be either a REG or a SUBREG.
5028 ??? Is it actually still ever a SUBREG? If so, why? */
5030 if (GET_CODE (reloadreg
) == REG
)
5031 return gen_rtx (REG
, GET_MODE (*loc
),
5032 REGNO (reloadreg
) + SUBREG_WORD (*loc
));
5033 else if (GET_MODE (reloadreg
) == GET_MODE (*loc
))
5036 return gen_rtx (SUBREG
, GET_MODE (*loc
), SUBREG_REG (reloadreg
),
5037 SUBREG_WORD (reloadreg
) + SUBREG_WORD (*loc
));
5044 /* Return nonzero if register in range [REGNO, ENDREGNO)
5045 appears either explicitly or implicitly in X
5046 other than being stored into (except for earlyclobber operands).
5048 References contained within the substructure at LOC do not count.
5049 LOC may be zero, meaning don't ignore anything.
5051 This is similar to refers_to_regno_p in rtlanal.c except that we
5052 look at equivalences for pseudos that didn't get hard registers. */
5055 refers_to_regno_for_reload_p (regno
, endregno
, x
, loc
)
5056 int regno
, endregno
;
5061 register RTX_CODE code
;
5068 code
= GET_CODE (x
);
5075 /* If this is a pseudo, a hard register must not have been allocated.
5076 X must therefore either be a constant or be in memory. */
5077 if (i
>= FIRST_PSEUDO_REGISTER
)
5079 if (reg_equiv_memory_loc
[i
])
5080 return refers_to_regno_for_reload_p (regno
, endregno
,
5081 reg_equiv_memory_loc
[i
],
5084 if (reg_equiv_constant
[i
])
5090 return (endregno
> i
5091 && regno
< i
+ (i
< FIRST_PSEUDO_REGISTER
5092 ? HARD_REGNO_NREGS (i
, GET_MODE (x
))
5096 /* If this is a SUBREG of a hard reg, we can see exactly which
5097 registers are being modified. Otherwise, handle normally. */
5098 if (GET_CODE (SUBREG_REG (x
)) == REG
5099 && REGNO (SUBREG_REG (x
)) < FIRST_PSEUDO_REGISTER
)
5101 int inner_regno
= REGNO (SUBREG_REG (x
)) + SUBREG_WORD (x
);
5103 = inner_regno
+ (inner_regno
< FIRST_PSEUDO_REGISTER
5104 ? HARD_REGNO_NREGS (regno
, GET_MODE (x
)) : 1);
5106 return endregno
> inner_regno
&& regno
< inner_endregno
;
5112 if (&SET_DEST (x
) != loc
5113 /* Note setting a SUBREG counts as referring to the REG it is in for
5114 a pseudo but not for hard registers since we can
5115 treat each word individually. */
5116 && ((GET_CODE (SET_DEST (x
)) == SUBREG
5117 && loc
!= &SUBREG_REG (SET_DEST (x
))
5118 && GET_CODE (SUBREG_REG (SET_DEST (x
))) == REG
5119 && REGNO (SUBREG_REG (SET_DEST (x
))) >= FIRST_PSEUDO_REGISTER
5120 && refers_to_regno_for_reload_p (regno
, endregno
,
5121 SUBREG_REG (SET_DEST (x
)),
5123 /* If the ouput is an earlyclobber operand, this is
5125 || ((GET_CODE (SET_DEST (x
)) != REG
5126 || earlyclobber_operand_p (SET_DEST (x
)))
5127 && refers_to_regno_for_reload_p (regno
, endregno
,
5128 SET_DEST (x
), loc
))))
5131 if (code
== CLOBBER
|| loc
== &SET_SRC (x
))
5137 /* X does not match, so try its subexpressions. */
5139 fmt
= GET_RTX_FORMAT (code
);
5140 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
5142 if (fmt
[i
] == 'e' && loc
!= &XEXP (x
, i
))
5150 if (refers_to_regno_for_reload_p (regno
, endregno
,
5154 else if (fmt
[i
] == 'E')
5157 for (j
= XVECLEN (x
, i
) - 1; j
>=0; j
--)
5158 if (loc
!= &XVECEXP (x
, i
, j
)
5159 && refers_to_regno_for_reload_p (regno
, endregno
,
5160 XVECEXP (x
, i
, j
), loc
))
5167 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
5168 we check if any register number in X conflicts with the relevant register
5169 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
5170 contains a MEM (we don't bother checking for memory addresses that can't
5171 conflict because we expect this to be a rare case.
5173 This function is similar to reg_overlap_mention_p in rtlanal.c except
5174 that we look at equivalences for pseudos that didn't get hard registers. */
5177 reg_overlap_mentioned_for_reload_p (x
, in
)
5180 int regno
, endregno
;
5182 if (GET_CODE (x
) == SUBREG
)
5184 regno
= REGNO (SUBREG_REG (x
));
5185 if (regno
< FIRST_PSEUDO_REGISTER
)
5186 regno
+= SUBREG_WORD (x
);
5188 else if (GET_CODE (x
) == REG
)
5192 /* If this is a pseudo, it must not have been assigned a hard register.
5193 Therefore, it must either be in memory or be a constant. */
5195 if (regno
>= FIRST_PSEUDO_REGISTER
)
5197 if (reg_equiv_memory_loc
[regno
])
5198 return refers_to_mem_for_reload_p (in
);
5199 else if (reg_equiv_constant
[regno
])
5204 else if (CONSTANT_P (x
))
5206 else if (GET_CODE (x
) == MEM
)
5207 return refers_to_mem_for_reload_p (in
);
5208 else if (GET_CODE (x
) == SCRATCH
|| GET_CODE (x
) == PC
5209 || GET_CODE (x
) == CC0
)
5210 return reg_mentioned_p (x
, in
);
5214 endregno
= regno
+ (regno
< FIRST_PSEUDO_REGISTER
5215 ? HARD_REGNO_NREGS (regno
, GET_MODE (x
)) : 1);
5217 return refers_to_regno_for_reload_p (regno
, endregno
, in
, NULL_PTR
);
5220 /* Return nonzero if anything in X contains a MEM. Look also for pseudo
5224 refers_to_mem_for_reload_p (x
)
5230 if (GET_CODE (x
) == MEM
)
5233 if (GET_CODE (x
) == REG
)
5234 return (REGNO (x
) >= FIRST_PSEUDO_REGISTER
5235 && reg_equiv_memory_loc
[REGNO (x
)]);
5237 fmt
= GET_RTX_FORMAT (GET_CODE (x
));
5238 for (i
= GET_RTX_LENGTH (GET_CODE (x
)) - 1; i
>= 0; i
--)
5240 && (GET_CODE (XEXP (x
, i
)) == MEM
5241 || refers_to_mem_for_reload_p (XEXP (x
, i
))))
5247 /* Check the insns before INSN to see if there is a suitable register
5248 containing the same value as GOAL.
5249 If OTHER is -1, look for a register in class CLASS.
5250 Otherwise, just see if register number OTHER shares GOAL's value.
5252 Return an rtx for the register found, or zero if none is found.
5254 If RELOAD_REG_P is (short *)1,
5255 we reject any hard reg that appears in reload_reg_rtx
5256 because such a hard reg is also needed coming into this insn.
5258 If RELOAD_REG_P is any other nonzero value,
5259 it is a vector indexed by hard reg number
5260 and we reject any hard reg whose element in the vector is nonnegative
5261 as well as any that appears in reload_reg_rtx.
5263 If GOAL is zero, then GOALREG is a register number; we look
5264 for an equivalent for that register.
5266 MODE is the machine mode of the value we want an equivalence for.
5267 If GOAL is nonzero and not VOIDmode, then it must have mode MODE.
5269 This function is used by jump.c as well as in the reload pass.
5271 If GOAL is the sum of the stack pointer and a constant, we treat it
5272 as if it were a constant except that sp is required to be unchanging. */
5275 find_equiv_reg (goal
, insn
, class, other
, reload_reg_p
, goalreg
, mode
)
5278 enum reg_class
class;
5280 short *reload_reg_p
;
5282 enum machine_mode mode
;
5284 register rtx p
= insn
;
5285 rtx goaltry
, valtry
, value
, where
;
5287 register int regno
= -1;
5291 int goal_mem_addr_varies
= 0;
5292 int need_stable_sp
= 0;
5298 else if (GET_CODE (goal
) == REG
)
5299 regno
= REGNO (goal
);
5300 else if (GET_CODE (goal
) == MEM
)
5302 enum rtx_code code
= GET_CODE (XEXP (goal
, 0));
5303 if (MEM_VOLATILE_P (goal
))
5305 if (flag_float_store
&& GET_MODE_CLASS (GET_MODE (goal
)) == MODE_FLOAT
)
5307 /* An address with side effects must be reexecuted. */
5318 else if (CONSTANT_P (goal
))
5320 else if (GET_CODE (goal
) == PLUS
5321 && XEXP (goal
, 0) == stack_pointer_rtx
5322 && CONSTANT_P (XEXP (goal
, 1)))
5323 goal_const
= need_stable_sp
= 1;
5327 /* On some machines, certain regs must always be rejected
5328 because they don't behave the way ordinary registers do. */
5330 #ifdef OVERLAPPING_REGNO_P
5331 if (regno
>= 0 && regno
< FIRST_PSEUDO_REGISTER
5332 && OVERLAPPING_REGNO_P (regno
))
5336 /* Scan insns back from INSN, looking for one that copies
5337 a value into or out of GOAL.
5338 Stop and give up if we reach a label. */
5343 if (p
== 0 || GET_CODE (p
) == CODE_LABEL
)
5345 if (GET_CODE (p
) == INSN
5346 /* If we don't want spill regs ... */
5347 && (! (reload_reg_p
!= 0
5348 && reload_reg_p
!= (short *) (HOST_WIDE_INT
) 1)
5349 /* ... then ignore insns introduced by reload; they aren't useful
5350 and can cause results in reload_as_needed to be different
5351 from what they were when calculating the need for spills.
5352 If we notice an input-reload insn here, we will reject it below,
5353 but it might hide a usable equivalent. That makes bad code.
5354 It may even abort: perhaps no reg was spilled for this insn
5355 because it was assumed we would find that equivalent. */
5356 || INSN_UID (p
) < reload_first_uid
))
5359 pat
= single_set (p
);
5360 /* First check for something that sets some reg equal to GOAL. */
5363 && true_regnum (SET_SRC (pat
)) == regno
5364 && (valueno
= true_regnum (valtry
= SET_DEST (pat
))) >= 0)
5367 && true_regnum (SET_DEST (pat
)) == regno
5368 && (valueno
= true_regnum (valtry
= SET_SRC (pat
))) >= 0)
5370 (goal_const
&& rtx_equal_p (SET_SRC (pat
), goal
)
5371 && (valueno
= true_regnum (valtry
= SET_DEST (pat
))) >= 0)
5373 && (valueno
= true_regnum (valtry
= SET_DEST (pat
))) >= 0
5374 && rtx_renumbered_equal_p (goal
, SET_SRC (pat
)))
5376 && (valueno
= true_regnum (valtry
= SET_SRC (pat
))) >= 0
5377 && rtx_renumbered_equal_p (goal
, SET_DEST (pat
)))
5378 /* If we are looking for a constant,
5379 and something equivalent to that constant was copied
5380 into a reg, we can use that reg. */
5381 || (goal_const
&& (tem
= find_reg_note (p
, REG_EQUIV
,
5383 && rtx_equal_p (XEXP (tem
, 0), goal
)
5384 && (valueno
= true_regnum (valtry
= SET_DEST (pat
))) >= 0)
5385 || (goal_const
&& (tem
= find_reg_note (p
, REG_EQUIV
,
5387 && GET_CODE (SET_DEST (pat
)) == REG
5388 && GET_CODE (XEXP (tem
, 0)) == CONST_DOUBLE
5389 && GET_MODE_CLASS (GET_MODE (XEXP (tem
, 0))) == MODE_FLOAT
5390 && GET_CODE (goal
) == CONST_INT
5391 && 0 != (goaltry
= operand_subword (XEXP (tem
, 0), 0, 0,
5393 && rtx_equal_p (goal
, goaltry
)
5394 && (valtry
= operand_subword (SET_DEST (pat
), 0, 0,
5396 && (valueno
= true_regnum (valtry
)) >= 0)
5397 || (goal_const
&& (tem
= find_reg_note (p
, REG_EQUIV
,
5399 && GET_CODE (SET_DEST (pat
)) == REG
5400 && GET_CODE (XEXP (tem
, 0)) == CONST_DOUBLE
5401 && GET_MODE_CLASS (GET_MODE (XEXP (tem
, 0))) == MODE_FLOAT
5402 && GET_CODE (goal
) == CONST_INT
5403 && 0 != (goaltry
= operand_subword (XEXP (tem
, 0), 1, 0,
5405 && rtx_equal_p (goal
, goaltry
)
5407 = operand_subword (SET_DEST (pat
), 1, 0, VOIDmode
))
5408 && (valueno
= true_regnum (valtry
)) >= 0)))
5411 : ((unsigned) valueno
< FIRST_PSEUDO_REGISTER
5412 && TEST_HARD_REG_BIT (reg_class_contents
[(int) class],
5422 /* We found a previous insn copying GOAL into a suitable other reg VALUE
5423 (or copying VALUE into GOAL, if GOAL is also a register).
5424 Now verify that VALUE is really valid. */
5426 /* VALUENO is the register number of VALUE; a hard register. */
5428 /* Don't try to re-use something that is killed in this insn. We want
5429 to be able to trust REG_UNUSED notes. */
5430 if (find_reg_note (where
, REG_UNUSED
, value
))
5433 /* If we propose to get the value from the stack pointer or if GOAL is
5434 a MEM based on the stack pointer, we need a stable SP. */
5435 if (valueno
== STACK_POINTER_REGNUM
5436 || (goal_mem
&& reg_overlap_mentioned_for_reload_p (stack_pointer_rtx
,
5440 /* Reject VALUE if the copy-insn moved the wrong sort of datum. */
5441 if (GET_MODE (value
) != mode
)
5444 /* Reject VALUE if it was loaded from GOAL
5445 and is also a register that appears in the address of GOAL. */
5447 if (goal_mem
&& value
== SET_DEST (PATTERN (where
))
5448 && refers_to_regno_for_reload_p (valueno
,
5450 + HARD_REGNO_NREGS (valueno
, mode
)),
5454 /* Reject registers that overlap GOAL. */
5456 if (!goal_mem
&& !goal_const
5457 && regno
+ HARD_REGNO_NREGS (regno
, mode
) > valueno
5458 && regno
< valueno
+ HARD_REGNO_NREGS (valueno
, mode
))
5461 /* Reject VALUE if it is one of the regs reserved for reloads.
5462 Reload1 knows how to reuse them anyway, and it would get
5463 confused if we allocated one without its knowledge.
5464 (Now that insns introduced by reload are ignored above,
5465 this case shouldn't happen, but I'm not positive.) */
5467 if (reload_reg_p
!= 0 && reload_reg_p
!= (short *) (HOST_WIDE_INT
) 1
5468 && reload_reg_p
[valueno
] >= 0)
5471 /* On some machines, certain regs must always be rejected
5472 because they don't behave the way ordinary registers do. */
5474 #ifdef OVERLAPPING_REGNO_P
5475 if (OVERLAPPING_REGNO_P (valueno
))
5479 nregs
= HARD_REGNO_NREGS (regno
, mode
);
5480 valuenregs
= HARD_REGNO_NREGS (valueno
, mode
);
5482 /* Reject VALUE if it is a register being used for an input reload
5483 even if it is not one of those reserved. */
5485 if (reload_reg_p
!= 0)
5488 for (i
= 0; i
< n_reloads
; i
++)
5489 if (reload_reg_rtx
[i
] != 0 && reload_in
[i
])
5491 int regno1
= REGNO (reload_reg_rtx
[i
]);
5492 int nregs1
= HARD_REGNO_NREGS (regno1
,
5493 GET_MODE (reload_reg_rtx
[i
]));
5494 if (regno1
< valueno
+ valuenregs
5495 && regno1
+ nregs1
> valueno
)
5501 /* We must treat frame pointer as varying here,
5502 since it can vary--in a nonlocal goto as generated by expand_goto. */
5503 goal_mem_addr_varies
= !CONSTANT_ADDRESS_P (XEXP (goal
, 0));
5505 /* Now verify that the values of GOAL and VALUE remain unaltered
5506 until INSN is reached. */
5515 /* Don't trust the conversion past a function call
5516 if either of the two is in a call-clobbered register, or memory. */
5517 if (GET_CODE (p
) == CALL_INSN
5518 && ((regno
>= 0 && regno
< FIRST_PSEUDO_REGISTER
5519 && call_used_regs
[regno
])
5521 (valueno
>= 0 && valueno
< FIRST_PSEUDO_REGISTER
5522 && call_used_regs
[valueno
])
5528 #ifdef INSN_CLOBBERS_REGNO_P
5529 if ((valueno
>= 0 && valueno
< FIRST_PSEUDO_REGISTER
5530 && INSN_CLOBBERS_REGNO_P (p
, valueno
))
5531 || (regno
>= 0 && regno
< FIRST_PSEUDO_REGISTER
5532 && INSN_CLOBBERS_REGNO_P (p
, regno
)))
5536 if (GET_RTX_CLASS (GET_CODE (p
)) == 'i')
5538 /* If this insn P stores in either GOAL or VALUE, return 0.
5539 If GOAL is a memory ref and this insn writes memory, return 0.
5540 If GOAL is a memory ref and its address is not constant,
5541 and this insn P changes a register used in GOAL, return 0. */
5544 if (GET_CODE (pat
) == SET
|| GET_CODE (pat
) == CLOBBER
)
5546 register rtx dest
= SET_DEST (pat
);
5547 while (GET_CODE (dest
) == SUBREG
5548 || GET_CODE (dest
) == ZERO_EXTRACT
5549 || GET_CODE (dest
) == SIGN_EXTRACT
5550 || GET_CODE (dest
) == STRICT_LOW_PART
)
5551 dest
= XEXP (dest
, 0);
5552 if (GET_CODE (dest
) == REG
)
5554 register int xregno
= REGNO (dest
);
5556 if (REGNO (dest
) < FIRST_PSEUDO_REGISTER
)
5557 xnregs
= HARD_REGNO_NREGS (xregno
, GET_MODE (dest
));
5560 if (xregno
< regno
+ nregs
&& xregno
+ xnregs
> regno
)
5562 if (xregno
< valueno
+ valuenregs
5563 && xregno
+ xnregs
> valueno
)
5565 if (goal_mem_addr_varies
5566 && reg_overlap_mentioned_for_reload_p (dest
, goal
))
5569 else if (goal_mem
&& GET_CODE (dest
) == MEM
5570 && ! push_operand (dest
, GET_MODE (dest
)))
5572 else if (GET_CODE (dest
) == MEM
&& regno
>= FIRST_PSEUDO_REGISTER
5573 && reg_equiv_memory_loc
[regno
] != 0)
5575 else if (need_stable_sp
&& push_operand (dest
, GET_MODE (dest
)))
5578 else if (GET_CODE (pat
) == PARALLEL
)
5581 for (i
= XVECLEN (pat
, 0) - 1; i
>= 0; i
--)
5583 register rtx v1
= XVECEXP (pat
, 0, i
);
5584 if (GET_CODE (v1
) == SET
|| GET_CODE (v1
) == CLOBBER
)
5586 register rtx dest
= SET_DEST (v1
);
5587 while (GET_CODE (dest
) == SUBREG
5588 || GET_CODE (dest
) == ZERO_EXTRACT
5589 || GET_CODE (dest
) == SIGN_EXTRACT
5590 || GET_CODE (dest
) == STRICT_LOW_PART
)
5591 dest
= XEXP (dest
, 0);
5592 if (GET_CODE (dest
) == REG
)
5594 register int xregno
= REGNO (dest
);
5596 if (REGNO (dest
) < FIRST_PSEUDO_REGISTER
)
5597 xnregs
= HARD_REGNO_NREGS (xregno
, GET_MODE (dest
));
5600 if (xregno
< regno
+ nregs
5601 && xregno
+ xnregs
> regno
)
5603 if (xregno
< valueno
+ valuenregs
5604 && xregno
+ xnregs
> valueno
)
5606 if (goal_mem_addr_varies
5607 && reg_overlap_mentioned_for_reload_p (dest
,
5611 else if (goal_mem
&& GET_CODE (dest
) == MEM
5612 && ! push_operand (dest
, GET_MODE (dest
)))
5614 else if (need_stable_sp
5615 && push_operand (dest
, GET_MODE (dest
)))
5621 if (GET_CODE (p
) == CALL_INSN
&& CALL_INSN_FUNCTION_USAGE (p
))
5625 for (link
= CALL_INSN_FUNCTION_USAGE (p
); XEXP (link
, 1) != 0;
5626 link
= XEXP (link
, 1))
5628 pat
= XEXP (link
, 0);
5629 if (GET_CODE (pat
) == CLOBBER
)
5631 register rtx dest
= SET_DEST (pat
);
5632 while (GET_CODE (dest
) == SUBREG
5633 || GET_CODE (dest
) == ZERO_EXTRACT
5634 || GET_CODE (dest
) == SIGN_EXTRACT
5635 || GET_CODE (dest
) == STRICT_LOW_PART
)
5636 dest
= XEXP (dest
, 0);
5637 if (GET_CODE (dest
) == REG
)
5639 register int xregno
= REGNO (dest
);
5641 if (REGNO (dest
) < FIRST_PSEUDO_REGISTER
)
5642 xnregs
= HARD_REGNO_NREGS (xregno
, GET_MODE (dest
));
5645 if (xregno
< regno
+ nregs
5646 && xregno
+ xnregs
> regno
)
5648 if (xregno
< valueno
+ valuenregs
5649 && xregno
+ xnregs
> valueno
)
5651 if (goal_mem_addr_varies
5652 && reg_overlap_mentioned_for_reload_p (dest
,
5656 else if (goal_mem
&& GET_CODE (dest
) == MEM
5657 && ! push_operand (dest
, GET_MODE (dest
)))
5659 else if (need_stable_sp
5660 && push_operand (dest
, GET_MODE (dest
)))
5667 /* If this insn auto-increments or auto-decrements
5668 either regno or valueno, return 0 now.
5669 If GOAL is a memory ref and its address is not constant,
5670 and this insn P increments a register used in GOAL, return 0. */
5674 for (link
= REG_NOTES (p
); link
; link
= XEXP (link
, 1))
5675 if (REG_NOTE_KIND (link
) == REG_INC
5676 && GET_CODE (XEXP (link
, 0)) == REG
)
5678 register int incno
= REGNO (XEXP (link
, 0));
5679 if (incno
< regno
+ nregs
&& incno
>= regno
)
5681 if (incno
< valueno
+ valuenregs
&& incno
>= valueno
)
5683 if (goal_mem_addr_varies
5684 && reg_overlap_mentioned_for_reload_p (XEXP (link
, 0),
5694 /* Find a place where INCED appears in an increment or decrement operator
5695 within X, and return the amount INCED is incremented or decremented by.
5696 The value is always positive. */
5699 find_inc_amount (x
, inced
)
5702 register enum rtx_code code
= GET_CODE (x
);
5708 register rtx addr
= XEXP (x
, 0);
5709 if ((GET_CODE (addr
) == PRE_DEC
5710 || GET_CODE (addr
) == POST_DEC
5711 || GET_CODE (addr
) == PRE_INC
5712 || GET_CODE (addr
) == POST_INC
)
5713 && XEXP (addr
, 0) == inced
)
5714 return GET_MODE_SIZE (GET_MODE (x
));
5717 fmt
= GET_RTX_FORMAT (code
);
5718 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
5722 register int tem
= find_inc_amount (XEXP (x
, i
), inced
);
5729 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
5731 register int tem
= find_inc_amount (XVECEXP (x
, i
, j
), inced
);
5741 /* Return 1 if register REGNO is the subject of a clobber in insn INSN. */
5744 regno_clobbered_p (regno
, insn
)
5748 if (GET_CODE (PATTERN (insn
)) == CLOBBER
5749 && GET_CODE (XEXP (PATTERN (insn
), 0)) == REG
)
5750 return REGNO (XEXP (PATTERN (insn
), 0)) == regno
;
5752 if (GET_CODE (PATTERN (insn
)) == PARALLEL
)
5754 int i
= XVECLEN (PATTERN (insn
), 0) - 1;
5758 rtx elt
= XVECEXP (PATTERN (insn
), 0, i
);
5759 if (GET_CODE (elt
) == CLOBBER
&& GET_CODE (XEXP (elt
, 0)) == REG
5760 && REGNO (XEXP (elt
, 0)) == regno
)
5768 static char *reload_when_needed_name
[] =
5771 "RELOAD_FOR_OUTPUT",
5773 "RELOAD_FOR_INPUT_ADDRESS",
5774 "RELOAD_FOR_OUTPUT_ADDRESS",
5775 "RELOAD_FOR_OPERAND_ADDRESS",
5776 "RELOAD_FOR_OPADDR_ADDR",
5778 "RELOAD_FOR_OTHER_ADDRESS"
5781 static char *reg_class_names
[] = REG_CLASS_NAMES
;
5783 /* This function is used to print the variables set by 'find_reloads' */
5790 fprintf (stderr
, "\nn_reloads = %d\n", n_reloads
);
5792 for (r
= 0; r
< n_reloads
; r
++)
5794 fprintf (stderr
, "\nRELOAD %d\n", r
);
5798 fprintf (stderr
, "\nreload_in (%s) = ",
5799 GET_MODE_NAME (reload_inmode
[r
]));
5800 debug_rtx (reload_in
[r
]);
5805 fprintf (stderr
, "\nreload_out (%s) = ",
5806 GET_MODE_NAME (reload_outmode
[r
]));
5807 debug_rtx (reload_out
[r
]);
5810 fprintf (stderr
, "%s, ", reg_class_names
[(int) reload_reg_class
[r
]]);
5812 fprintf (stderr
, "%s (opnum = %d)",
5813 reload_when_needed_name
[(int)reload_when_needed
[r
]],
5816 if (reload_optional
[r
])
5817 fprintf (stderr
, ", optional");
5820 fprintf (stderr
, ", inc by %d\n", reload_inc
[r
]);
5822 if (reload_nocombine
[r
])
5823 fprintf (stderr
, ", can combine", reload_nocombine
[r
]);
5825 if (reload_secondary_p
[r
])
5826 fprintf (stderr
, ", secondary_reload_p");
5828 if (reload_in_reg
[r
])
5830 fprintf (stderr
, "\nreload_in_reg:\t\t\t");
5831 debug_rtx (reload_in_reg
[r
]);
5834 if (reload_reg_rtx
[r
])
5836 fprintf (stderr
, "\nreload_reg_rtx:\t\t\t");
5837 debug_rtx (reload_reg_rtx
[r
]);
5840 if (reload_secondary_in_reload
[r
] != -1)
5842 fprintf (stderr
, "\nsecondary_in_reload = ");
5843 fprintf (stderr
, "%d ", reload_secondary_in_reload
[r
]);
5846 if (reload_secondary_out_reload
[r
] != -1)
5848 if (reload_secondary_in_reload
[r
] != -1)
5849 fprintf (stderr
, ", secondary_out_reload = ");
5851 fprintf (stderr
, "\nsecondary_out_reload = ");
5853 fprintf (stderr
, "%d", reload_secondary_out_reload
[r
]);
5857 if (reload_secondary_in_icode
[r
] != CODE_FOR_nothing
)
5859 fprintf (stderr
, "\nsecondary_in_icode = ");
5860 fprintf (stderr
, "%s", insn_name
[r
]);
5863 if (reload_secondary_out_icode
[r
] != CODE_FOR_nothing
)
5865 if (reload_secondary_in_icode
[r
] != CODE_FOR_nothing
)
5866 fprintf (stderr
, ", secondary_out_icode = ");
5868 fprintf (stderr
, "\nsecondary_out_icode = ");
5870 fprintf (stderr
, "%s ", insn_name
[r
]);
5872 fprintf (stderr
, "\n");
5875 fprintf (stderr
, "\n");