1 /* Save and restore call-clobbered registers which are live across a call.
2 Copyright (C) 1989, 92, 94, 95, 97-99, 2000 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, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
24 #include "insn-config.h"
27 #include "hard-reg-set.h"
29 #include "basic-block.h"
37 #define MAX_MOVE_MAX MOVE_MAX
40 #ifndef MIN_UNITS_PER_WORD
41 #define MIN_UNITS_PER_WORD UNITS_PER_WORD
44 #define MOVE_MAX_WORDS (MOVE_MAX / UNITS_PER_WORD)
46 /* Modes for each hard register that we can save. The smallest mode is wide
47 enough to save the entire contents of the register. When saving the
48 register because it is live we first try to save in multi-register modes.
49 If that is not possible the save is done one register at a time. */
51 static enum machine_mode
52 regno_save_mode[FIRST_PSEUDO_REGISTER][MAX_MOVE_MAX / MIN_UNITS_PER_WORD + 1];
54 /* For each hard register, a place on the stack where it can be saved,
58 regno_save_mem[FIRST_PSEUDO_REGISTER][MAX_MOVE_MAX / MIN_UNITS_PER_WORD + 1];
60 /* We will only make a register eligible for caller-save if it can be
61 saved in its widest mode with a simple SET insn as long as the memory
62 address is valid. We record the INSN_CODE is those insns here since
63 when we emit them, the addresses might not be valid, so they might not
67 reg_save_code[FIRST_PSEUDO_REGISTER][MAX_MOVE_MAX / MIN_UNITS_PER_WORD + 1];
69 reg_restore_code[FIRST_PSEUDO_REGISTER][MAX_MOVE_MAX / MIN_UNITS_PER_WORD + 1];
71 /* Set of hard regs currently residing in save area (during insn scan). */
73 static HARD_REG_SET hard_regs_saved;
75 /* Number of registers currently in hard_regs_saved. */
77 static int n_regs_saved;
79 /* Computed by mark_referenced_regs, all regs referenced in a given
81 static HARD_REG_SET referenced_regs;
83 /* Computed in mark_set_regs, holds all registers set by the current
85 static HARD_REG_SET this_insn_sets;
88 static void mark_set_regs PARAMS ((rtx, rtx, void *));
89 static void mark_referenced_regs PARAMS ((rtx));
90 static int insert_save PARAMS ((struct insn_chain *, int, int,
92 static int insert_restore PARAMS ((struct insn_chain *, int, int,
94 static struct insn_chain *insert_one_insn PARAMS ((struct insn_chain *, int,
95 enum insn_code, rtx));
97 /* Initialize for caller-save.
99 Look at all the hard registers that are used by a call and for which
100 regclass.c has not already excluded from being used across a call.
102 Ensure that we can find a mode to save the register and that there is a
103 simple insn to save and restore the register. This latter check avoids
104 problems that would occur if we tried to save the MQ register of some
105 machines directly into memory. */
110 char *first_obj = (char *) oballoc (0);
116 /* First find all the registers that we need to deal with and all
117 the modes that they can have. If we can't find a mode to use,
118 we can't have the register live over calls. */
120 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
122 if (call_used_regs[i] && ! call_fixed_regs[i])
124 for (j = 1; j <= MOVE_MAX_WORDS; j++)
126 regno_save_mode[i][j] = HARD_REGNO_CALLER_SAVE_MODE (i, j);
127 if (regno_save_mode[i][j] == VOIDmode && j == 1)
129 call_fixed_regs[i] = 1;
130 SET_HARD_REG_BIT (call_fixed_reg_set, i);
135 regno_save_mode[i][1] = VOIDmode;
138 /* The following code tries to approximate the conditions under which
139 we can easily save and restore a register without scratch registers or
140 other complexities. It will usually work, except under conditions where
141 the validity of an insn operand is dependent on the address offset.
142 No such cases are currently known.
144 We first find a typical offset from some BASE_REG_CLASS register.
145 This address is chosen by finding the first register in the class
146 and by finding the smallest power of two that is a valid offset from
147 that register in every mode we will use to save registers. */
149 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
150 if (TEST_HARD_REG_BIT (reg_class_contents[(int) BASE_REG_CLASS], i))
153 if (i == FIRST_PSEUDO_REGISTER)
156 addr_reg = gen_rtx_REG (Pmode, i);
158 for (offset = 1 << (HOST_BITS_PER_INT / 2); offset; offset >>= 1)
160 address = gen_rtx_PLUS (Pmode, addr_reg, GEN_INT (offset));
162 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
163 if (regno_save_mode[i][1] != VOIDmode
164 && ! strict_memory_address_p (regno_save_mode[i][1], address))
167 if (i == FIRST_PSEUDO_REGISTER)
171 /* If we didn't find a valid address, we must use register indirect. */
175 /* Next we try to form an insn to save and restore the register. We
176 see if such an insn is recognized and meets its constraints. */
180 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
181 for (j = 1; j <= MOVE_MAX_WORDS; j++)
182 if (regno_save_mode[i][j] != VOIDmode)
184 rtx mem = gen_rtx_MEM (regno_save_mode[i][j], address);
185 rtx reg = gen_rtx_REG (regno_save_mode[i][j], i);
186 rtx savepat = gen_rtx_SET (VOIDmode, mem, reg);
187 rtx restpat = gen_rtx_SET (VOIDmode, reg, mem);
188 rtx saveinsn = emit_insn (savepat);
189 rtx restinsn = emit_insn (restpat);
192 reg_save_code[i][j] = recog_memoized (saveinsn);
193 reg_restore_code[i][j] = recog_memoized (restinsn);
195 /* Now extract both insns and see if we can meet their
197 ok = (reg_save_code[i][j] != (enum insn_code)-1
198 && reg_restore_code[i][j] != (enum insn_code)-1);
201 extract_insn (saveinsn);
202 ok = constrain_operands (1);
203 extract_insn (restinsn);
204 ok &= constrain_operands (1);
209 regno_save_mode[i][j] = VOIDmode;
212 call_fixed_regs[i] = 1;
213 SET_HARD_REG_BIT (call_fixed_reg_set, i);
223 /* Initialize save areas by showing that we haven't allocated any yet. */
230 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
231 for (j = 1; j <= MOVE_MAX_WORDS; j++)
232 regno_save_mem[i][j] = 0;
235 /* Allocate save areas for any hard registers that might need saving.
236 We take a conservative approach here and look for call-clobbered hard
237 registers that are assigned to pseudos that cross calls. This may
238 overestimate slightly (especially if some of these registers are later
239 used as spill registers), but it should not be significant.
243 In the fallback case we should iterate backwards across all possible
244 modes for the save, choosing the largest available one instead of
245 falling back to the smallest mode immediately. (eg TF -> DF -> SF).
247 We do not try to use "move multiple" instructions that exist
248 on some machines (such as the 68k moveml). It could be a win to try
249 and use them when possible. The hard part is doing it in a way that is
250 machine independent since they might be saving non-consecutive
251 registers. (imagine caller-saving d0,d1,a0,a1 on the 68k) */
257 HARD_REG_SET hard_regs_used;
259 /* Allocate space in the save area for the largest multi-register
260 pseudos first, then work backwards to single register
263 /* Find and record all call-used hard-registers in this function. */
264 CLEAR_HARD_REG_SET (hard_regs_used);
265 for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
266 if (reg_renumber[i] >= 0 && REG_N_CALLS_CROSSED (i) > 0)
268 int regno = reg_renumber[i];
270 = regno + HARD_REGNO_NREGS (regno, GET_MODE (regno_reg_rtx[i]));
271 int nregs = endregno - regno;
273 for (j = 0; j < nregs; j++)
275 if (call_used_regs[regno+j])
276 SET_HARD_REG_BIT (hard_regs_used, regno+j);
280 /* Now run through all the call-used hard-registers and allocate
281 space for them in the caller-save area. Try to allocate space
282 in a manner which allows multi-register saves/restores to be done. */
284 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
285 for (j = MOVE_MAX_WORDS; j > 0; j--)
289 /* If no mode exists for this size, try another. Also break out
290 if we have already saved this hard register. */
291 if (regno_save_mode[i][j] == VOIDmode || regno_save_mem[i][1] != 0)
294 /* See if any register in this group has been saved. */
295 for (k = 0; k < j; k++)
296 if (regno_save_mem[i + k][1])
304 for (k = 0; k < j; k++)
305 if (! TEST_HARD_REG_BIT (hard_regs_used, i + k))
313 /* We have found an acceptable mode to store in. */
315 = assign_stack_local (regno_save_mode[i][j],
316 GET_MODE_SIZE (regno_save_mode[i][j]), 0);
318 /* Setup single word save area just in case... */
319 for (k = 0; k < j; k++)
321 /* This should not depend on WORDS_BIG_ENDIAN.
322 The order of words in regs is the same as in memory. */
323 rtx temp = gen_rtx_MEM (regno_save_mode[i+k][1],
324 XEXP (regno_save_mem[i][j], 0));
326 regno_save_mem[i+k][1]
327 = adj_offsettable_operand (temp, k * UNITS_PER_WORD);
332 /* Find the places where hard regs are live across calls and save them. */
334 save_call_clobbered_regs ()
336 struct insn_chain *chain, *next;
338 CLEAR_HARD_REG_SET (hard_regs_saved);
341 for (chain = reload_insn_chain; chain != 0; chain = next)
343 rtx insn = chain->insn;
344 enum rtx_code code = GET_CODE (insn);
348 if (chain->is_caller_save_insn)
351 if (GET_RTX_CLASS (code) == 'i')
353 /* If some registers have been saved, see if INSN references
354 any of them. We must restore them before the insn if so. */
360 if (code == JUMP_INSN)
361 /* Restore all registers if this is a JUMP_INSN. */
362 COPY_HARD_REG_SET (referenced_regs, hard_regs_saved);
365 CLEAR_HARD_REG_SET (referenced_regs);
366 mark_referenced_regs (PATTERN (insn));
367 AND_HARD_REG_SET (referenced_regs, hard_regs_saved);
370 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
371 if (TEST_HARD_REG_BIT (referenced_regs, regno))
372 regno += insert_restore (chain, 1, regno, MOVE_MAX_WORDS);
375 if (code == CALL_INSN)
378 HARD_REG_SET hard_regs_to_save;
380 /* Use the register life information in CHAIN to compute which
381 regs are live during the call. */
382 REG_SET_TO_HARD_REG_SET (hard_regs_to_save,
383 &chain->live_throughout);
384 compute_use_by_pseudos (&hard_regs_to_save,
385 &chain->live_throughout);
387 /* Record all registers set in this call insn. These don't need
388 to be saved. N.B. the call insn might set a subreg of a
389 multi-hard-reg pseudo; then the pseudo is considered live
390 during the call, but the subreg that is set isn't. */
391 CLEAR_HARD_REG_SET (this_insn_sets);
392 note_stores (PATTERN (insn), mark_set_regs, NULL);
394 /* Compute which hard regs must be saved before this call. */
395 AND_COMPL_HARD_REG_SET (hard_regs_to_save, call_fixed_reg_set);
396 AND_COMPL_HARD_REG_SET (hard_regs_to_save, this_insn_sets);
397 AND_COMPL_HARD_REG_SET (hard_regs_to_save, hard_regs_saved);
398 AND_HARD_REG_SET (hard_regs_to_save, call_used_reg_set);
400 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
401 if (TEST_HARD_REG_BIT (hard_regs_to_save, regno))
402 regno += insert_save (chain, 1, regno, &hard_regs_to_save);
404 /* Must recompute n_regs_saved. */
406 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
407 if (TEST_HARD_REG_BIT (hard_regs_saved, regno))
412 if (chain->next == 0 || chain->next->block > chain->block)
415 /* At the end of the basic block, we must restore any registers that
416 remain saved. If the last insn in the block is a JUMP_INSN, put
417 the restore before the insn, otherwise, put it after the insn. */
420 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
421 if (TEST_HARD_REG_BIT (hard_regs_saved, regno))
422 regno += insert_restore (chain, GET_CODE (insn) == JUMP_INSN,
423 regno, MOVE_MAX_WORDS);
428 /* Here from note_stores when an insn stores a value in a register.
429 Set the proper bit or bits in this_insn_sets. All pseudos that have
430 been assigned hard regs have had their register number changed already,
431 so we can ignore pseudos. */
433 mark_set_regs (reg, setter, data)
435 rtx setter ATTRIBUTE_UNUSED;
436 void *data ATTRIBUTE_UNUSED;
438 register int regno, endregno, i;
439 enum machine_mode mode = GET_MODE (reg);
442 if (GET_CODE (reg) == SUBREG)
444 word = SUBREG_WORD (reg);
445 reg = SUBREG_REG (reg);
448 if (GET_CODE (reg) != REG || REGNO (reg) >= FIRST_PSEUDO_REGISTER)
451 regno = REGNO (reg) + word;
452 endregno = regno + HARD_REGNO_NREGS (regno, mode);
454 for (i = regno; i < endregno; i++)
455 SET_HARD_REG_BIT (this_insn_sets, i);
458 /* Here from note_stores when an insn stores a value in a register.
459 Set the proper bit or bits in the passed regset. All pseudos that have
460 been assigned hard regs have had their register number changed already,
461 so we can ignore pseudos. */
463 add_stored_regs (reg, setter, data)
468 register int regno, endregno, i;
469 enum machine_mode mode = GET_MODE (reg);
472 if (GET_CODE (setter) == CLOBBER)
475 while (GET_CODE (reg) == SUBREG)
477 word += SUBREG_WORD (reg);
478 reg = SUBREG_REG (reg);
481 if (GET_CODE (reg) != REG || REGNO (reg) >= FIRST_PSEUDO_REGISTER)
484 regno = REGNO (reg) + word;
485 endregno = regno + HARD_REGNO_NREGS (regno, mode);
487 for (i = regno; i < endregno; i++)
488 SET_REGNO_REG_SET ((regset) data, i);
491 /* Walk X and record all referenced registers in REFERENCED_REGS. */
493 mark_referenced_regs (x)
496 enum rtx_code code = GET_CODE (x);
501 mark_referenced_regs (SET_SRC (x));
502 if (code == SET || code == CLOBBER)
506 if (code == REG || code == PC || code == CC0
507 || (code == SUBREG && GET_CODE (SUBREG_REG (x)) == REG))
510 if (code == MEM || code == SUBREG)
518 int regno = REGNO (x);
519 int hardregno = (regno < FIRST_PSEUDO_REGISTER ? regno
520 : reg_renumber[regno]);
524 int nregs = HARD_REGNO_NREGS (hardregno, GET_MODE (x));
526 SET_HARD_REG_BIT (referenced_regs, hardregno + nregs);
528 /* If this is a pseudo that did not get a hard register, scan its
529 memory location, since it might involve the use of another
530 register, which might be saved. */
531 else if (reg_equiv_mem[regno] != 0)
532 mark_referenced_regs (XEXP (reg_equiv_mem[regno], 0));
533 else if (reg_equiv_address[regno] != 0)
534 mark_referenced_regs (reg_equiv_address[regno]);
538 fmt = GET_RTX_FORMAT (code);
539 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
542 mark_referenced_regs (XEXP (x, i));
543 else if (fmt[i] == 'E')
544 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
545 mark_referenced_regs (XVECEXP (x, i, j));
549 /* Insert a sequence of insns to restore. Place these insns in front of
550 CHAIN if BEFORE_P is nonzero, behind the insn otherwise. MAXRESTORE is
551 the maximum number of registers which should be restored during this call.
552 It should never be less than 1 since we only work with entire registers.
554 Note that we have verified in init_caller_save that we can do this
555 with a simple SET, so use it. Set INSN_CODE to what we save there
556 since the address might not be valid so the insn might not be recognized.
557 These insns will be reloaded and have register elimination done by
558 find_reload, so we need not worry about that here.
560 Return the extra number of registers saved. */
563 insert_restore (chain, before_p, regno, maxrestore)
564 struct insn_chain *chain;
571 enum insn_code code = CODE_FOR_nothing;
573 struct insn_chain *new;
575 /* A common failure mode if register status is not correct in the RTL
576 is for this routine to be called with a REGNO we didn't expect to
577 save. That will cause us to write an insn with a (nil) SET_DEST
578 or SET_SRC. Instead of doing so and causing a crash later, check
579 for this common case and abort here instead. This will remove one
580 step in debugging such problems. */
582 if (regno_save_mem[regno][1] == 0)
585 /* Get the pattern to emit and update our status.
587 See if we can restore `maxrestore' registers at once. Work
588 backwards to the single register case. */
589 for (i = maxrestore; i > 0; i--)
594 if (regno_save_mem[regno][i] == 0)
597 for (j = 0; j < i; j++)
598 if (! TEST_HARD_REG_BIT (hard_regs_saved, regno + j))
603 /* Must do this one restore at a time */
611 pat = gen_rtx_SET (VOIDmode,
612 gen_rtx_REG (GET_MODE (regno_save_mem[regno][numregs]),
614 regno_save_mem[regno][numregs]);
615 code = reg_restore_code[regno][numregs];
616 new = insert_one_insn (chain, before_p, code, pat);
618 /* Clear status for all registers we restored. */
619 for (k = 0; k < i; k++)
621 CLEAR_HARD_REG_BIT (hard_regs_saved, regno + k);
622 SET_REGNO_REG_SET (&new->dead_or_set, regno + k);
628 /* Tell our callers how many extra registers we saved/restored */
632 /* Like insert_restore above, but save registers instead. */
634 insert_save (chain, before_p, regno, to_save)
635 struct insn_chain *chain;
638 HARD_REG_SET *to_save;
642 enum insn_code code = CODE_FOR_nothing;
644 struct insn_chain *new;
646 /* A common failure mode if register status is not correct in the RTL
647 is for this routine to be called with a REGNO we didn't expect to
648 save. That will cause us to write an insn with a (nil) SET_DEST
649 or SET_SRC. Instead of doing so and causing a crash later, check
650 for this common case and abort here instead. This will remove one
651 step in debugging such problems. */
653 if (regno_save_mem[regno][1] == 0)
656 /* Get the pattern to emit and update our status.
658 See if we can save several registers with a single instruction.
659 Work backwards to the single register case. */
660 for (i = MOVE_MAX_WORDS; i > 0; i--)
664 if (regno_save_mem[regno][i] == 0)
667 for (j = 0; j < i; j++)
668 if (! TEST_HARD_REG_BIT (*to_save, regno + j))
673 /* Must do this one save at a time */
681 pat = gen_rtx_SET (VOIDmode, regno_save_mem[regno][numregs],
682 gen_rtx_REG (GET_MODE (regno_save_mem[regno][numregs]),
684 code = reg_save_code[regno][numregs];
685 new = insert_one_insn (chain, before_p, code, pat);
687 /* Set hard_regs_saved and dead_or_set for all the registers we saved. */
688 for (k = 0; k < numregs; k++)
690 SET_HARD_REG_BIT (hard_regs_saved, regno + k);
691 SET_REGNO_REG_SET (&new->dead_or_set, regno + k);
695 /* Tell our callers how many extra registers we saved/restored */
699 /* Emit a new caller-save insn and set the code. */
700 static struct insn_chain *
701 insert_one_insn (chain, before_p, code, pat)
702 struct insn_chain *chain;
707 rtx insn = chain->insn;
708 struct insn_chain *new;
711 /* If INSN references CC0, put our insns in front of the insn that sets
712 CC0. This is always safe, since the only way we could be passed an
713 insn that references CC0 is for a restore, and doing a restore earlier
714 isn't a problem. We do, however, assume here that CALL_INSNs don't
715 reference CC0. Guard against non-INSN's like CODE_LABEL. */
717 if ((GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN)
719 && reg_referenced_p (cc0_rtx, PATTERN (insn)))
720 chain = chain->prev, insn = chain->insn;
723 new = new_insn_chain ();
728 new->prev = chain->prev;
730 new->prev->next = new;
732 reload_insn_chain = new;
736 new->insn = emit_insn_before (pat, insn);
737 /* ??? It would be nice if we could exclude the already / still saved
738 registers from the live sets. */
739 COPY_REG_SET (&new->live_throughout, &chain->live_throughout);
740 /* Registers that die in CHAIN->INSN still live in the new insn. */
741 for (link = REG_NOTES (chain->insn); link; link = XEXP (link, 1))
743 if (REG_NOTE_KIND (link) == REG_DEAD)
745 rtx reg = XEXP (link, 0);
748 if (GET_CODE (reg) != REG)
752 if (regno >= FIRST_PSEUDO_REGISTER)
753 regno = reg_renumber[regno];
756 for (i = HARD_REGNO_NREGS (regno, GET_MODE (reg)) - 1;
758 SET_REGNO_REG_SET (&new->live_throughout, regno + i);
761 CLEAR_REG_SET (&new->dead_or_set);
762 if (chain->insn == BLOCK_HEAD (chain->block))
763 BLOCK_HEAD (chain->block) = new->insn;
767 new->next = chain->next;
769 new->next->prev = new;
772 new->insn = emit_insn_after (pat, insn);
773 /* ??? It would be nice if we could exclude the already / still saved
774 registers from the live sets, and observe REG_UNUSED notes. */
775 COPY_REG_SET (&new->live_throughout, &chain->live_throughout);
776 /* Registers that are set in CHAIN->INSN live in the new insn.
777 (Unless there is a REG_UNUSED note for them, but we don't
778 look for them here.) */
779 note_stores (PATTERN (chain->insn), add_stored_regs,
780 &new->live_throughout);
781 CLEAR_REG_SET (&new->dead_or_set);
782 if (chain->insn == BLOCK_END (chain->block))
783 BLOCK_END (chain->block) = new->insn;
785 new->block = chain->block;
786 new->is_caller_save_insn = 1;
788 INSN_CODE (new->insn) = code;