OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
0dde4175ef
gcc/gcc/caller-save.c

758 lines
22 KiB
C
Raw Normal View History

Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
/* Save and restore call-clobbered registers which are live across a call.
Update copyrights. From-SVN: r24624
1999-01-12 00:15:28 +01:00
Copyright (C) 1989, 1992, 94-95, 97, 98, 1999 Free Software Foundation, Inc.
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
Update FSF address. From-SVN: r9959
1995-06-15 13:33:25 +02:00
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
#include "config.h"
Major cutover to using system.h: * Makefile.in (alias.o, bitmap.o, c-aux-info.o, c-common.o, c-decl.o, c-iterate.o, c-lang.o, c-lex.o, c-pragma.o, c-typeck.o, caller-save.o, calls.o, collect2.o, combine.o, cse.o, dbxout.o, dwarf2out.o, dwarfout.o, emit-rtl.o, except.o, explow.o, expmed.o, expr.o, final.o, flow.o, function.o, getpwd.o, global.o, integrate.o, jump.o, local-alloc.o, loop.o, optabs.o, pexecute.o, prefix.o, print-rtl.o, print-tree.o, profile.o, real.o, recog.o, reg-stack.o, regclass.o, regmove.o, reload.o, reload1.o, reorg.o, rtl.o, rtlanal.o, sdbout.o, stmt.o, stor-layout.o, stupid.o, tlink.o, toplev.o, tree.o, unroll.o, varasm.o, xcoffout.o): Depend on system.h. * alias.c, bitmap.c, c-aux-info.c, c-common.c, c-decl.c, c-iterate.c, c-lang.c, c-lex.c, c-pragma.c, c-typeck.c, caller-save.c, calls.c, collect2.c, combine.c, cse.c, dbxout.c, dwarf2out.c, dwarfout.c, emit-rtl.c, except.c, explow.c, expmed.c, expr.c, final.c, flow.c, function.c, gcc.c, getpwd.c, global.c, integrate.c, jump.c, local-alloc.c, loop.c, optabs.c, pexecute.c, prefix.c, print-rtl.c, print-tree.c, profile.c, real.c, recog.c, reg-stack.c, regclass.c, regmove.c, reload.c, reload1.c, reorg.c, rtl.c, rtlanal.c, sched.c, sdbout.c, stmt.c, stor-layout.c, stupid.c, tlink.c, toplev.c, tree.c, unroll.c, varasm.c, xcoffout.c: Include system.h. Organize include ordering so that stdarg/varargs comes before other system headers. Remove spurious casts of functions assured of a prototype in system.h. From-SVN: r18726
1998-03-20 15:58:42 +01:00
#include "system.h"
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
#include "rtl.h"
#include "insn-config.h"
#include "flags.h"
#include "regs.h"
#include "hard-reg-set.h"
#include "recog.h"
#include "basic-block.h"
#include "reload.h"
#include "expr.h"
alias.c: Include toplev.h * alias.c: Include toplev.h * caller-save.c: Include toplev.h * combine.c: Include toplev.h * flow.c Include toplev.h * global.c: Include toplev.h * jump.c: Include toplev.h * local-alloc.c: Include toplev.h * loop.c: Include toplev.h * regmove.c: Include toplev.h * stupid.c: Include toplev.h * unroll.c: Include toplev.h * Makefile.in: Add toplev.h dependencies. From-SVN: r20623
1998-06-20 01:37:04 +02:00
#include "toplev.h"
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
(MAX_MOVE_MAX, MAX_UNITS_PER_WORD): New macros. (regno_save_mode, regno_save_mem): Use them. From-SVN: r5102
1993-08-07 21:58:54 +02:00
#ifndef MAX_MOVE_MAX
#define MAX_MOVE_MAX MOVE_MAX
#endif
Replace MAX_UNITS_PER_WORD with MIN_UNITS_PER_WORD. From-SVN: r8904
1995-02-11 01:06:12 +01:00
#ifndef MIN_UNITS_PER_WORD
#define MIN_UNITS_PER_WORD UNITS_PER_WORD
(MAX_MOVE_MAX, MAX_UNITS_PER_WORD): New macros. (regno_save_mode, regno_save_mem): Use them. From-SVN: r5102
1993-08-07 21:58:54 +02:00
#endif
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
#define MOVE_MAX_WORDS (MOVE_MAX / UNITS_PER_WORD)
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
/* Modes for each hard register that we can save. The smallest mode is wide
enough to save the entire contents of the register. When saving the
register because it is live we first try to save in multi-register modes.
If that is not possible the save is done one register at a time. */
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
static enum machine_mode
Replace MAX_UNITS_PER_WORD with MIN_UNITS_PER_WORD. From-SVN: r8904
1995-02-11 01:06:12 +01:00
regno_save_mode[FIRST_PSEUDO_REGISTER][MAX_MOVE_MAX / MIN_UNITS_PER_WORD + 1];
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
/* For each hard register, a place on the stack where it can be saved,
if needed. */
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
static rtx
Replace MAX_UNITS_PER_WORD with MIN_UNITS_PER_WORD. From-SVN: r8904
1995-02-11 01:06:12 +01:00
regno_save_mem[FIRST_PSEUDO_REGISTER][MAX_MOVE_MAX / MIN_UNITS_PER_WORD + 1];
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
/* We will only make a register eligible for caller-save if it can be
saved in its widest mode with a simple SET insn as long as the memory
address is valid. We record the INSN_CODE is those insns here since
when we emit them, the addresses might not be valid, so they might not
be recognized. */
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
static enum insn_code
Replace MAX_UNITS_PER_WORD with MIN_UNITS_PER_WORD. From-SVN: r8904
1995-02-11 01:06:12 +01:00
reg_save_code[FIRST_PSEUDO_REGISTER][MAX_MOVE_MAX / MIN_UNITS_PER_WORD + 1];
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
static enum insn_code
Replace MAX_UNITS_PER_WORD with MIN_UNITS_PER_WORD. From-SVN: r8904
1995-02-11 01:06:12 +01:00
reg_restore_code[FIRST_PSEUDO_REGISTER][MAX_MOVE_MAX / MIN_UNITS_PER_WORD + 1];
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
/* Set of hard regs currently residing in save area (during insn scan). */
static HARD_REG_SET hard_regs_saved;
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
/* Number of registers currently in hard_regs_saved. */
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
static int n_regs_saved;
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
/* Computed by mark_referenced_regs, all regs referenced in a given
insn. */
static HARD_REG_SET referenced_regs;
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
/* Computed in mark_set_regs, holds all registers set by the current
instruction. */
static HARD_REG_SET this_insn_sets;
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
static void mark_set_regs PROTO((rtx, rtx));
static void mark_referenced_regs PROTO((rtx));
static int insert_save PROTO((struct insn_chain *, int, int,
HARD_REG_SET *));
static int insert_restore PROTO((struct insn_chain *, int, int,
int));
static void insert_one_insn PROTO((struct insn_chain *, int,
enum insn_code, rtx));
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
/* Initialize for caller-save.
Look at all the hard registers that are used by a call and for which
regclass.c has not already excluded from being used across a call.
Ensure that we can find a mode to save the register and that there is a
simple insn to save and restore the register. This latter check avoids
problems that would occur if we tried to save the MQ register of some
machines directly into memory. */
void
init_caller_save ()
{
char *first_obj = (char *) oballoc (0);
rtx addr_reg;
int offset;
rtx address;
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
int i, j;
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
/* First find all the registers that we need to deal with and all
the modes that they can have. If we can't find a mode to use,
we can't have the register live over calls. */
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
{
if (call_used_regs[i] && ! call_fixed_regs[i])
{
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
for (j = 1; j <= MOVE_MAX_WORDS; j++)
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
{
regs.h (HARD_REGNO_CALLER_SAVE_MODE): New macro. * regs.h (HARD_REGNO_CALLER_SAVE_MODE): New macro. * caller-save.c (init_caller_save): Use it. * tm.texi: Document HARD_REGNO_CALLER_SAVE_MODE. From-SVN: r22682
1998-09-30 19:21:12 +02:00
regno_save_mode[i][j] = HARD_REGNO_CALLER_SAVE_MODE (i, j);
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
if (regno_save_mode[i][j] == VOIDmode && j == 1)
{
call_fixed_regs[i] = 1;
SET_HARD_REG_BIT (call_fixed_reg_set, i);
}
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
}
}
else
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
regno_save_mode[i][1] = VOIDmode;
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
}
/* The following code tries to approximate the conditions under which
we can easily save and restore a register without scratch registers or
other complexities. It will usually work, except under conditions where
the validity of an insn operand is dependent on the address offset.
No such cases are currently known.
We first find a typical offset from some BASE_REG_CLASS register.
This address is chosen by finding the first register in the class
and by finding the smallest power of two that is a valid offset from
that register in every mode we will use to save registers. */
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
if (TEST_HARD_REG_BIT (reg_class_contents[(int) BASE_REG_CLASS], i))
break;
if (i == FIRST_PSEUDO_REGISTER)
abort ();
alias.c: Change all uses of gen_rtx(FOO...) to gen_rtx_FOO... * alias.c: Change all uses of gen_rtx(FOO...) to gen_rtx_FOO; change gen_rtx(expr...) to gen_rtx_fmt_foo(expr...). * caller-save.c, calls.c, combine.c, cse.c: Likewise. * dwarf2out.c, except.c, explow.c, expmed.c, expr.c: Likewise. * final.c, flow.c, function.c, genpeep.c, haifa-sched.c: Likewise. * halfpic.c, integrate.c, jump.c, local-alloc.c, loop.c: Likewise. * profile.c, recog.c, reg-stack.c, regclass.c, regmove.c: Likewise. * reload.c, reload1.c, reorg.c, sched.c, stmt.c, stupid.c: Likewise. * unroll.c, varasm.c: Likewise. * config/alpha/alpha.c, config/alpha/alpha.md: Likewise. From-SVN: r17357
1998-01-15 00:10:50 +01:00
addr_reg = gen_rtx_REG (Pmode, i);
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
for (offset = 1 << (HOST_BITS_PER_INT / 2); offset; offset >>= 1)
{
alias.c: Change all uses of gen_rtx(FOO...) to gen_rtx_FOO... * alias.c: Change all uses of gen_rtx(FOO...) to gen_rtx_FOO; change gen_rtx(expr...) to gen_rtx_fmt_foo(expr...). * caller-save.c, calls.c, combine.c, cse.c: Likewise. * dwarf2out.c, except.c, explow.c, expmed.c, expr.c: Likewise. * final.c, flow.c, function.c, genpeep.c, haifa-sched.c: Likewise. * halfpic.c, integrate.c, jump.c, local-alloc.c, loop.c: Likewise. * profile.c, recog.c, reg-stack.c, regclass.c, regmove.c: Likewise. * reload.c, reload1.c, reorg.c, sched.c, stmt.c, stupid.c: Likewise. * unroll.c, varasm.c: Likewise. * config/alpha/alpha.c, config/alpha/alpha.md: Likewise. From-SVN: r17357
1998-01-15 00:10:50 +01:00
address = gen_rtx_PLUS (Pmode, addr_reg, GEN_INT (offset));
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
if (regno_save_mode[i][1] != VOIDmode
&& ! strict_memory_address_p (regno_save_mode[i][1], address))
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
break;
if (i == FIRST_PSEUDO_REGISTER)
break;
}
/* If we didn't find a valid address, we must use register indirect. */
if (offset == 0)
address = addr_reg;
/* Next we try to form an insn to save and restore the register. We
see if such an insn is recognized and meets its constraints. */
start_sequence ();
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
for (j = 1; j <= MOVE_MAX_WORDS; j++)
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
if (regno_save_mode[i][j] != VOIDmode)
{
alias.c: Change all uses of gen_rtx(FOO...) to gen_rtx_FOO... * alias.c: Change all uses of gen_rtx(FOO...) to gen_rtx_FOO; change gen_rtx(expr...) to gen_rtx_fmt_foo(expr...). * caller-save.c, calls.c, combine.c, cse.c: Likewise. * dwarf2out.c, except.c, explow.c, expmed.c, expr.c: Likewise. * final.c, flow.c, function.c, genpeep.c, haifa-sched.c: Likewise. * halfpic.c, integrate.c, jump.c, local-alloc.c, loop.c: Likewise. * profile.c, recog.c, reg-stack.c, regclass.c, regmove.c: Likewise. * reload.c, reload1.c, reorg.c, sched.c, stmt.c, stupid.c: Likewise. * unroll.c, varasm.c: Likewise. * config/alpha/alpha.c, config/alpha/alpha.md: Likewise. From-SVN: r17357
1998-01-15 00:10:50 +01:00
rtx mem = gen_rtx_MEM (regno_save_mode[i][j], address);
rtx reg = gen_rtx_REG (regno_save_mode[i][j], i);
rtx savepat = gen_rtx_SET (VOIDmode, mem, reg);
rtx restpat = gen_rtx_SET (VOIDmode, reg, mem);
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
rtx saveinsn = emit_insn (savepat);
rtx restinsn = emit_insn (restpat);
int ok;
reg_save_code[i][j] = recog_memoized (saveinsn);
reg_restore_code[i][j] = recog_memoized (restinsn);
formatting tweaks From-SVN: r12390
1996-07-04 00:07:53 +02:00
/* Now extract both insns and see if we can meet their
constraints. */
Warning fixes: * Makefile.in (sched.o): Depend on recog.h. * alias.c (REG_BASE_VALUE): Cast the result of REGNO() macro to (unsigned) when comparing against one. (find_base_value): Likewise. (record_base_value): Cast variable `regno' to (unsigned) when comparing against one. Cast the result of REGNO() macro to (unsigned) when comparing against one. (memrefs_conflict_p): Change type of variables `r_x' and `r_y' to unsigned. (init_alias_analysis): Add unsigned variable `ui'. Use it as loop variable where an unsigned index is needed. * caller-save.c (init_caller_save): Cast `-1' to (enum insn_code) before comparing against one. * collect2.c: Add prototypes for functions `error', `fatal' and `fatal_perror'. Make these functions take variable arguments instead of faking it with a fixed number of args. (write_c_file_stat): Cast the argument of ctype macro to (unsigned char). * combine.c (can_combine_p): Mark parameter `pred' with ATTRIBUTE_UNUSED. (find_split_point): Cast variable `src' to (unsigned HOST_WIDE_INT) when comparing against one. HOST_WIDE_INT) when comparing against one. (simplify_rtx): Cast 1 to (unsigned HOST_WIDE_INT) in shift. (simplify_logical): Likewise. (force_to_mode): Cast result of INTVAL() macro to (unsigned HOST_WIDE_INT) when comparing against one. Cast 1 to (unsigned HOST_WIDE_INT) in shift. (simplify_and_const_int): Cast result of INTVAL() macro to `unsigned HOST_WIDE_INT' when comparing against one. (merge_outer_ops): Cast variable const0 to `unsigned HOST_WIDE_INT' when comparing against the result of GET_MODE_MASK() macro. (simplify_comparison): Likewise for variable `c0'. Cast variable `const_op' to `unsigned HOST_WIDE_INT' when comparing against one. Cast `1' to `unsigned HOST_WIDE_INT' in shift. Cast the result of `GET_MODE_MASK()/2' to `HOST_WIDE_INT' when comparing against one. Cast `1' to `unsigned HOST_WIDE_INT' in shift. Cast result of INTVAL() macro to `unsigned HOST_WIDE_INT' when comparing against one. (distribute_notes): Wrap variable `cc0_setter' in macro `HAVE_cc0'. config/mips/mips.c (gen_int_relational): Cast result of INTVAL() macro to `unsigned HOST_WIDE_INT' when comparing against one. (output_block_move): Cast `sizeof' expression to (int) when comparing against one. (function_arg): Cast BITS_PER_WORD to `unsigned' when comparing against one. (save_restore_insns): Cast `base_offset' to `long' to match format specifier in fprintf. * config/mips/mips.h (Pmode): Cast the result of `Pmode' macro to `enum machine_mode'. * flow.c (life_analysis_1): Remove unused variable `insn'. * gcc.c (translate_options): Move variables `j' and `k' into the scope in which they are used. Change their types to `size_t'. (set_spec): Cast the argument of ctype macro to `unsigned char'. (read_specs): Likewise. (process_command): Cast `sizeof' to (int) when comparing against one. (do_spec_1): Cast the argument of ctype macro to `unsigned char'. (handle_braces): Cast both sides of `==' expression to `long' to ensure sign matching. (main): Cast variable `i' to `int' when comparing against one. * gcov-io.h (__fetch_long): Change type of parameter `bytes' from int to size_t. Cast variable `i' to size_t when comparing against one. * genattrtab.c (convert_set_attr_alternative): Remove unused parameter `insn_code'. All callers changed. (convert_set_attr): Likewise. * genrecog.c (add_to_sequence): Cast result of XVECLEN() macro to size_t when comparing against one. Likewise for variable `len'. * global.c (global_alloc): Cast variable `max_regno' to size_t when comparing against one. Likewise for variable `max_allocno'. * jump.c (sets_cc0_p): Mark parameter `x' with ATTRIBUTE_UNUSED. * local-alloc.c (validate_equiv_mem_from_store): Mark parameter `set' with ATTRIBUTE_UNUSED. (find_free_reg): Cast `sizeof' expression to (int) when comparing against one. * loop.c (count_loop_regs_set): Remove unused variable `dest'. (strength_reduce): Mark parameter `bct_p' with ATTRIBUTE_UNUSED. (get_condition): Cast variable `const_val' to `unsigned HOST_WIDE_INT' when comparing against one. Cast unsigned expression to HOST_WIDE_INT when comparing against one. (insert_loop_mem): Mark parameter `data' with ATTRIBUTE_UNUSED. (load_mems_and_recount_loop_regs_set): Cast variable `nregs' to `unsigned' when comparing against one. * protoize.c (is_id_char): Change type of parameter `ch' to unsigned char. (munge_compile_params): Cast argument of ctype macro to (const unsigned char). (process_aux_info_file): Cast variable `aux_info_size' to int when comparing against one. (forward_to_next_token_char): Cast argument of ctype macro to `const unsigned char'. (edit_formals_lists): Likewise. (find_rightmost_formals_list): Likewise. (add_local_decl): Likewise. (add_global_decls): Likewise. (edit_fn_definition): Likewise. (do_cleaning): Likewise. (scan_for_missed_items): Likewise. (edit_file): Cast variable `orig_size' to (int) when comparing against one. (main): Cast argument of ctype macro to `const unsigned char'. * recog.c (const_int_operand): Mark parameter `mode' with ATTRIBUTE_UNUSED. * regclass.c (record_reg_classes): Change type of variable `c' to `unsigned char'. Cast `char' array index to `unsigned char'. * reload.c (push_secondary_reload): Cast argument to REG_CLASS_FROM_LETTER() macro to `unsigned char'. * reload1.c (calculate_needs): Cast `char' array index to `unsigned char'. (set_label_offsets): Change type of variable `i' to unsigned int. Cast result of XVECLEN() macro to unsigned when comparing against one. (mark_not_eliminable): Change type of variable `i' to unsigned. (order_regs_for_reload): Likewise. Cast `max_regno' to unsigned when comparing against one. (reload_as_needed): Cast macro NUM_ELIMINABLE_REGS to (int) when comparing against one. (choose_reload_regs): Hide unused label `fail'. (reload_cse_simplify_operands): Cast `char' array index to `unsigned char'. (reload_combine_note_store): Mark parameter `set' with ATTRIBUTE_UNUSED. Cast UNITS_PER_WORD to unsigned when comparing against one. (reload_cse_move2add): Remove unused variable `src2'. * sched.c: Include recog.h. (sched_note_set): Remove unused parameter `b'. All callers changed. (split_hard_reg_notes): Likewise for parameter `orig_insn'. (blockage_range): Cast result of UNIT_BLOCKED() macro to (int) when comparing against one. * stupid.c (stupid_find_reg): Mark parameter `changes_size' with ATTRIBUTE_UNUSED. Cast `sizeof' expression to (int) when comparing against one. * unroll.c (precondition_loop_p): Remove unused parameter `loop_end'. All callers changed. From-SVN: r23079
1998-10-14 11:02:55 +02:00
ok = (reg_save_code[i][j] != (enum insn_code)-1
&& reg_restore_code[i][j] != (enum insn_code)-1);
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
if (ok)
{
recog.h (enum op_type): Define. * recog.h (enum op_type): Define. (constrain_operands): Adjust prototype. (recog_op_type): Declare new variable. * recog.c (recog_op_type): New variable. (insn_invalid_p): Allow modifying an asm statement after reload. (extract_insn): Set up recog_op_type. (constrain_operands): Lose INSN_CODE_NUM arg. All callers changed. Don't compute operand types, use recog_op_type. Use the information computed by extract_insn instead of the previous method of finding it by insn code number. * caller-save.c (init_caller_save): Use extract_insn, not insn_extract. * reorg.c (fill_slots_from_thread): Likewise. * reload1.c (reload_as_needed): Likewise. (gen_reload): Likewise. (inc_for_reload): Likewise. (reload_cse_simplify_operands): Likewise. Use the information computed by extract_insn instead of the previous method of finding it by insn code number. * genattrtab.c (write_attr_case): Generate call to extract_insn, not insn_extract. * final.c (final_scan_insn): Use extract_insn, not insn_extract. (cleanup_operand_subregs): Use extract_insn, not insn_extract. Use the information computed by extract_insn instead of the previous method of finding it by insn code number. * regmove.c (find_matches): Likewise. Change meaning of the return value to be nonzero if the optimization can be performed, zero if not. All callers changed. Shorten some variable names to fix formatting problems. (regmove_optimize): Shorten some variable names to fix formatting problems. Use the information computed by extract_insn instead of the previous method of finding it by insn code number. * regclass.c (scan_one_insn): Likewise. (record_reg_classes): Don't compute operand types, use recog_op_type. * reload.c (find_reloads): Lose CONSTRAINTS1 variable; use recog_constraints instead. From-SVN: r23529
1998-11-04 22:25:00 +01:00
extract_insn (saveinsn);
ok = constrain_operands (1);
extract_insn (restinsn);
ok &= constrain_operands (1);
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
}
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
caller-save.c (init_caller_save): If we were unable to find a simple insn which meets all its constraints to save... * caller-save.c (init_caller_save): If we were unable to find a simple insn which meets all its constraints to save and restore with a single insn in a mode, then set regno_save_mode to VOIDmode to insure that this mode is never used to caller-save the current register. From-SVN: r2038
1992-09-03 01:08:44 +02:00
if (! ok)
{
regno_save_mode[i][j] = VOIDmode;
if (j == 1)
{
call_fixed_regs[i] = 1;
SET_HARD_REG_BIT (call_fixed_reg_set, i);
}
}
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
}
end_sequence ();
obfree (first_obj);
}
/* Initialize save areas by showing that we haven't allocated any yet. */
void
init_save_areas ()
{
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
int i, j;
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
for (j = 1; j <= MOVE_MAX_WORDS; j++)
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
regno_save_mem[i][j] = 0;
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
}
/* Allocate save areas for any hard registers that might need saving.
We take a conservative approach here and look for call-clobbered hard
registers that are assigned to pseudos that cross calls. This may
overestimate slightly (especially if some of these registers are later
used as spill registers), but it should not be significant.
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
Future work:
In the fallback case we should iterate backwards across all possible
modes for the save, choosing the largest available one instead of
falling back to the smallest mode immediately. (eg TF -> DF -> SF).
We do not try to use "move multiple" instructions that exist
on some machines (such as the 68k moveml). It could be a win to try
and use them when possible. The hard part is doing it in a way that is
machine independent since they might be saving non-consecutive
registers. (imagine caller-saving d0,d1,a0,a1 on the 68k) */
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
caller-save.c (restore_referenced_regs): Lose mode argument. * caller-save.c (restore_referenced_regs): Lose mode argument. (insert_save): Lose mode argument. (insert_restore): Lose mode argument. (insert_one_insn): Lose mode argument. (save_call_clobbered_regs): Lose mode argument. (setup_save_areas): Take no argument and return void. All callers changed. Don't verify validity of memory addresses. * reload.h (setup_save_ares): Adjust prototype. (save_call_clobbered_regs): Likewise. * reload1.c (delete_caller_save_insns): New function. (caller_save_spill_class): Delete variable. (caller_save_group_size): Delete variable. (reload): Call setup_save_areas and save_call_clobbered_regs in the main loop, before calling calculate_needs_all_insns. Don't call save_call_clobbered_regs after the loop. Call delete_caller_save_insns at the end of an iteration if something changed. Delete code to manage caller_save_spill_class. Emit the final note before setting reload_first_uid. Simplify test that determines whether reload_as_needed gets run. (calculate_needs): Delete code to manage caller_save_spill_class. From-SVN: r22876
1998-10-07 02:13:49 +02:00
void
setup_save_areas ()
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
{
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
int i, j, k;
HARD_REG_SET hard_regs_used;
/* Allocate space in the save area for the largest multi-register
pseudos first, then work backwards to single register
pseudos. */
/* Find and record all call-used hard-registers in this function. */
CLEAR_HARD_REG_SET (hard_regs_used);
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
Use accessor macros to access arrays based on regno; move many of the arrays into a single structure. From-SVN: r14140
1997-05-30 20:19:19 +02:00
if (reg_renumber[i] >= 0 && REG_N_CALLS_CROSSED (i) > 0)
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
{
int regno = reg_renumber[i];
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
int endregno
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
= regno + HARD_REGNO_NREGS (regno, GET_MODE (regno_reg_rtx[i]));
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
int nregs = endregno - regno;
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
for (j = 0; j < nregs; j++)
{
if (call_used_regs[regno+j])
SET_HARD_REG_BIT (hard_regs_used, regno+j);
}
}
/* Now run through all the call-used hard-registers and allocate
space for them in the caller-save area. Try to allocate space
in a manner which allows multi-register saves/restores to be done. */
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
for (j = MOVE_MAX_WORDS; j > 0; j--)
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
{
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
int do_save = 1;
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
/* If no mode exists for this size, try another. Also break out
if we have already saved this hard register. */
if (regno_save_mode[i][j] == VOIDmode || regno_save_mem[i][1] != 0)
continue;
(setup_save_areas): Don't assign save area for a group if some register in the group has already been assigned an area. From-SVN: r3000
1992-12-30 13:02:45 +01:00
/* See if any register in this group has been saved. */
for (k = 0; k < j; k++)
if (regno_save_mem[i + k][1])
{
do_save = 0;
break;
}
if (! do_save)
continue;
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
for (k = 0; k < j; k++)
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
if (! TEST_HARD_REG_BIT (hard_regs_used, i + k))
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
{
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
do_save = 0;
break;
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
}
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
if (! do_save)
continue;
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
formatting tweaks From-SVN: r12390
1996-07-04 00:07:53 +02:00
/* We have found an acceptable mode to store in. */
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
regno_save_mem[i][j]
= assign_stack_local (regno_save_mode[i][j],
GET_MODE_SIZE (regno_save_mode[i][j]), 0);
/* Setup single word save area just in case... */
for (k = 0; k < j; k++)
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
{
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
/* This should not depend on WORDS_BIG_ENDIAN.
The order of words in regs is the same as in memory. */
rtx temp = gen_rtx_MEM (regno_save_mode[i+k][1],
XEXP (regno_save_mem[i][j], 0));
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
regno_save_mem[i+k][1]
= adj_offsettable_operand (temp, k * UNITS_PER_WORD);
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
}
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
}
}
caller-save.c (restore_referenced_regs): Lose mode argument. * caller-save.c (restore_referenced_regs): Lose mode argument. (insert_save): Lose mode argument. (insert_restore): Lose mode argument. (insert_one_insn): Lose mode argument. (save_call_clobbered_regs): Lose mode argument. (setup_save_areas): Take no argument and return void. All callers changed. Don't verify validity of memory addresses. * reload.h (setup_save_ares): Adjust prototype. (save_call_clobbered_regs): Likewise. * reload1.c (delete_caller_save_insns): New function. (caller_save_spill_class): Delete variable. (caller_save_group_size): Delete variable. (reload): Call setup_save_areas and save_call_clobbered_regs in the main loop, before calling calculate_needs_all_insns. Don't call save_call_clobbered_regs after the loop. Call delete_caller_save_insns at the end of an iteration if something changed. Delete code to manage caller_save_spill_class. Emit the final note before setting reload_first_uid. Simplify test that determines whether reload_as_needed gets run. (calculate_needs): Delete code to manage caller_save_spill_class. From-SVN: r22876
1998-10-07 02:13:49 +02:00
/* Find the places where hard regs are live across calls and save them. */
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
void
caller-save.c (restore_referenced_regs): Lose mode argument. * caller-save.c (restore_referenced_regs): Lose mode argument. (insert_save): Lose mode argument. (insert_restore): Lose mode argument. (insert_one_insn): Lose mode argument. (save_call_clobbered_regs): Lose mode argument. (setup_save_areas): Take no argument and return void. All callers changed. Don't verify validity of memory addresses. * reload.h (setup_save_ares): Adjust prototype. (save_call_clobbered_regs): Likewise. * reload1.c (delete_caller_save_insns): New function. (caller_save_spill_class): Delete variable. (caller_save_group_size): Delete variable. (reload): Call setup_save_areas and save_call_clobbered_regs in the main loop, before calling calculate_needs_all_insns. Don't call save_call_clobbered_regs after the loop. Call delete_caller_save_insns at the end of an iteration if something changed. Delete code to manage caller_save_spill_class. Emit the final note before setting reload_first_uid. Simplify test that determines whether reload_as_needed gets run. (calculate_needs): Delete code to manage caller_save_spill_class. From-SVN: r22876
1998-10-07 02:13:49 +02:00
save_call_clobbered_regs ()
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
{
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
struct insn_chain *chain, *next;
CLEAR_HARD_REG_SET (hard_regs_saved);
n_regs_saved = 0;
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
for (chain = reload_insn_chain; chain != 0; chain = next)
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
{
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
rtx insn = chain->insn;
enum rtx_code code = GET_CODE (insn);
next = chain->next;
if (chain->is_caller_save_insn)
abort ();
if (GET_RTX_CLASS (code) == 'i')
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
{
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
/* If some registers have been saved, see if INSN references
any of them. We must restore them before the insn if so. */
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
if (n_regs_saved)
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
{
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
int regno;
if (code == JUMP_INSN)
/* Restore all registers if this is a JUMP_INSN. */
COPY_HARD_REG_SET (referenced_regs, hard_regs_saved);
(insert_save_restore): Change from USE and CLOBBER insns to using CALL_INSN_FUNCTION_USAGE. From-SVN: r7243
1994-05-06 23:49:35 +02:00
else
(save_call_clobbered_regs): If AUTO_INC_DEC, mark register indicated by REG_INC notes as live so they will be saved. From-SVN: r10010
1995-06-19 22:30:25 +02:00
{
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
CLEAR_HARD_REG_SET (referenced_regs);
mark_referenced_regs (PATTERN (insn));
AND_HARD_REG_SET (referenced_regs, hard_regs_saved);
(save_call_clobbered_regs): If AUTO_INC_DEC, mark register indicated by REG_INC notes as live so they will be saved. From-SVN: r10010
1995-06-19 22:30:25 +02:00
}
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
if (TEST_HARD_REG_BIT (referenced_regs, regno))
regno += insert_restore (chain, 1, regno, MOVE_MAX_WORDS);
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
}
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
if (code == CALL_INSN)
{
rtx x;
int regno, nregs;
HARD_REG_SET hard_regs_to_save;
/* Use the register life information in CHAIN to compute which
regs are live before the call. */
REG_SET_TO_HARD_REG_SET (hard_regs_to_save, chain->live_before);
compute_use_by_pseudos (&hard_regs_to_save, chain->live_before);
/* Record all registers set in this call insn. These don't need
to be saved. */
CLEAR_HARD_REG_SET (this_insn_sets);
note_stores (PATTERN (insn), mark_set_regs);
/* Compute which hard regs must be saved before this call. */
AND_COMPL_HARD_REG_SET (hard_regs_to_save, call_fixed_reg_set);
AND_COMPL_HARD_REG_SET (hard_regs_to_save, this_insn_sets);
AND_COMPL_HARD_REG_SET (hard_regs_to_save, hard_regs_saved);
AND_HARD_REG_SET (hard_regs_to_save, call_used_reg_set);
/* Registers used for function parameters need not be saved. */
for (x = CALL_INSN_FUNCTION_USAGE (insn); x != 0;
x = XEXP (x, 1))
{
rtx y;
if (GET_CODE (XEXP (x, 0)) != USE)
continue;
y = XEXP (XEXP (x, 0), 0);
if (GET_CODE (y) != REG)
abort ();
regno = REGNO (y);
if (REGNO (y) >= FIRST_PSEUDO_REGISTER)
abort ();
nregs = HARD_REGNO_NREGS (regno, GET_MODE (y));
while (nregs-- > 0)
CLEAR_HARD_REG_BIT (hard_regs_to_save, regno + nregs);
}
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
/* Neither do registers for which we find a death note. */
for (x = REG_NOTES (insn); x != 0; x = XEXP (x, 1))
{
rtx y = XEXP (x, 0);
if (REG_NOTE_KIND (x) != REG_DEAD)
continue;
if (GET_CODE (y) != REG)
abort ();
regno = REGNO (y);
if (regno >= FIRST_PSEUDO_REGISTER)
regno = reg_renumber[regno];
if (regno < 0)
continue;
nregs = HARD_REGNO_NREGS (regno, GET_MODE (y));
while (nregs-- > 0)
CLEAR_HARD_REG_BIT (hard_regs_to_save, regno + nregs);
}
for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
if (TEST_HARD_REG_BIT (hard_regs_to_save, regno))
regno += insert_save (chain, 1, regno, &hard_regs_to_save);
/* Must recompute n_regs_saved. */
n_regs_saved = 0;
for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
if (TEST_HARD_REG_BIT (hard_regs_saved, regno))
n_regs_saved++;
}
}
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
if (chain->next == 0 || chain->next->block > chain->block)
{
int regno;
/* At the end of the basic block, we must restore any registers that
remain saved. If the last insn in the block is a JUMP_INSN, put
the restore before the insn, otherwise, put it after the insn. */
if (n_regs_saved)
for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
if (TEST_HARD_REG_BIT (hard_regs_saved, regno))
regno += insert_restore (chain, GET_CODE (insn) == JUMP_INSN,
regno, MOVE_MAX_WORDS);
}
}
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
}
/* Here from note_stores when an insn stores a value in a register.
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
Set the proper bit or bits in this_insn_sets. All pseudos that have
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
been assigned hard regs have had their register number changed already,
so we can ignore pseudos. */
static void
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
mark_set_regs (reg, setter)
Warning fixes: * Makefile.in (c-lang.o): Depend on c-tree.h, c-lex.h and toplev.h. (c-lex.o): Depend on output.h. (c-common.o): Likewise. (stmt.o): Likewise. (calls.o): Likewise. (integrate.o): Depend on toplev.h. (regclass.o): Depend on output.h. (final.o): Depend on reload.h. * c-common.c: Include output.h. (check_format_info): Remove unused variable `integral_format'. * c-decl.c (print_lang_decl): Mark parameters `file', `node' and `indent' with ATTRIBUTE_UNUSED. (print_lang_type): Likewise. (maybe_build_cleanup): Likewise for parameter `decl'. (copy_lang_decl): Likewise for parameter `node'. * c-lang.c: Include c-tree.h, c-lex.h and toplev.h. (lang_print_xnode): Mark parameters `file', `node' and `indent' with ATTRIBUTE_UNUSED. (lookup_interface): Likewise for parameter `arg'. (is_class_name): Likewise. (maybe_objc_check_decl): Likewise for parameter `decl'. (maybe_objc_comptypes): Likewise for parameters `lhs', `rhs' and `reflexive'. (maybe_objc_method_name): Likewise for parameter `decl'. (build_objc_string): Likewise for parameters `len' and `str'. * c-lex.c: Include output.h. * c-lex.h (position_after_white_space): Correct typo in prototype. * c-tree.h (finish_file, c_expand_start_cond, c_expand_start_else, c_expand_end_cond, init_iterators): Add prototypes. * caller-save.c (set_reg_live): Mark parameters `reg' and `setter' with ATTRIBUTE_UNUSED. * calls.c: Include output.h. * cccp.c (pipe_closed): Mark parameter `signo' with ATTRIBUTE_UNUSED. * combine.c: Move inclusion of expr.h to after insn-config.h. * iris6.h (ASM_IDENTIFY_GCC, ASM_IDENTIFY_LANGUAGE): Don't define as empty, rather define as ((void)0). * sparc.c (sparc_check_64): Add braces around ambiguous `else'. Add parentheses around assignment used as truth value. * cplus-dem.c (squangle_mop_up): Change return type to void. (internal_cplus_demangle): Remove unused parameter `options'. All callers changed. (cplus_demangle_opname): Remove function wide variable `int i' and replace with `size_t i' at each location where it is used. (cplus_demangle_opname): change type of `i' from int to size_t. * cppexp.c (right_shift): Mark parameter `pfile' with ATTRIBUTE_UNUSED. * cpphash.c (cpp_lookup): Likewise. (cpp_hash_cleanup): Likewise. * cpplib.c (parse_name): Add a prototype and make it static. (null_underflow): Mark parameter `pfile' with ATTRIBUTE_UNUSED. (null_cleanup): Likewise for parameters `pbuf' and `pfile'. (macro_cleanup): Likewise for parameter `pfile'. (file_cleanup): Likewise. * cpplib.h (cpp_reader_init, cpp_options_init, cpp_start_read, cpp_read_check_assertion, skip_rest_of_line): Add prototypes. * crtstuff.c (force_to_data, __CTOR_LIST__, force_to_data, __DTOR_END__, __FRAME_END__): Mark with ATTRIBUTE_UNUSED. * cse.c (cse_check_loop_start): Mark parameter `set' with ATTRIBUTE_UNUSED. * dbxout.c (flag_minimal_debug, have_used_extensions, source_label_number): Move inside macro wrapper check against defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO). * dwarf2out.c (gen_entry_point_die): Hide prototype and definition. * except.h (doing_eh): Provide prototype. * expr.c: Move inclusion of expr.h to after insn-config.h. * final.c: Include reload.h. (shorten_branches): Cast the first argument of bzero to char *. * fix-header.c (cpp_print_containing_files): Mark parameter `pfile' with ATTRIBUTE_UNUSED. (cpp_fatal): Likewise. * flow.c (find_basic_blocks_1): Cast the first argument of bzero to char *. * genattrtab.c (make_length_attrs): Change the type of variable `i' from int to size_t. (zero_fn): Mark parameter `exp' with ATTRIBUTE_UNUSED. (one_fn): Likewise. * genextract.c (main): When generating insn-extract.c, mark variable `junk' with ATTRIBUTE_UNUSED. * gengenrtl.c (gencode): When generating genrtl.c, cast the first argument of bzero to char*. * integrate.c: Include toplev.h. * libgcc2.c: Wrap `struct exception_table' and `find_exception_handler' in macro DWARF2_UNWIND_INFO. * objc/Make-lang.in (objc-act.o): Depend on toplev.h. * objc/objc-act.c: Include toplev.h. (lang_print_xnode): Mark parameters `file', `node' and `indent' with ATTRIBUTE_UNUSED. (finish_protocol): Likewise for parameter `protocol'. * output.h (declare_weak): Add prototype. (decode_reg_name): Don't wrap with TREE_CODE macro. (assemble_alias): Add prototype. * regclass.c: Include output.h. * reload.h (reloads_conflict): Add prototype. * rtl.h (print_rtl_single, mark_elimiation, reg_class_subset_p, output_func_start_profiler): Add prototypes. * rtlanal.c (reg_set_p_1): Mark parameters `x' and `pat' with ATTRIBUTE_UNUSED. * scan-decls.c: Include scan.h. * scan.h (recognized_function, recognized_extern): Add prototypes. * stmt.c: Include output.h. * toplev.c (error_for_asm, warning_for_asm): Remove prototypes. (output_lang_identify): Hide prototype and definition. (float_signal): Mark parameter `signo' with ATTRIBUTE_UNUSED. (pipe_closed): Likewise. * toplev.h (count_error, strip_off_ending, error_for_asm, warning_for_asm): Add prototypes. From-SVN: r19712
1998-05-13 14:40:39 +02:00
rtx reg;
rtx setter ATTRIBUTE_UNUSED;
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
{
register int regno, endregno, i;
*** empty log message *** From-SVN: r352
1992-02-21 07:30:52 +01:00
enum machine_mode mode = GET_MODE (reg);
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
int word = 0;
if (GET_CODE (reg) == SUBREG)
{
word = SUBREG_WORD (reg);
reg = SUBREG_REG (reg);
}
if (GET_CODE (reg) != REG || REGNO (reg) >= FIRST_PSEUDO_REGISTER)
return;
regno = REGNO (reg) + word;
*** empty log message *** From-SVN: r352
1992-02-21 07:30:52 +01:00
endregno = regno + HARD_REGNO_NREGS (regno, mode);
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
for (i = regno; i < endregno; i++)
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
SET_HARD_REG_BIT (this_insn_sets, i);
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
}
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
/* Walk X and record all referenced registers in REFERENCED_REGS. */
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
static void
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
mark_referenced_regs (x)
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
rtx x;
{
enum rtx_code code = GET_CODE (x);
char *fmt;
int i, j;
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
if (code == SET)
mark_referenced_regs (SET_SRC (x));
if (code == SET || code == CLOBBER)
{
x = SET_DEST (x);
code = GET_CODE (x);
if (code == REG || code == PC || code == CC0
|| (code == SUBREG && GET_CODE (SUBREG_REG (x)) == REG))
return;
}
if (code == MEM || code == SUBREG)
{
x = XEXP (x, 0);
code = GET_CODE (x);
}
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
if (code == REG)
{
int regno = REGNO (x);
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
int hardregno = (regno < FIRST_PSEUDO_REGISTER ? regno
: reg_renumber[regno]);
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
if (hardregno >= 0)
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
{
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
int nregs = HARD_REGNO_NREGS (hardregno, GET_MODE (x));
while (nregs-- > 0)
SET_HARD_REG_BIT (referenced_regs, hardregno + nregs);
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
}
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
/* If this is a pseudo that did not get a hard register, scan its
memory location, since it might involve the use of another
register, which might be saved. */
else if (reg_equiv_mem[regno] != 0)
mark_referenced_regs (XEXP (reg_equiv_mem[regno], 0));
else if (reg_equiv_address[regno] != 0)
mark_referenced_regs (reg_equiv_address[regno]);
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
return;
}
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
fmt = GET_RTX_FORMAT (code);
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
{
if (fmt[i] == 'e')
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
mark_referenced_regs (XEXP (x, i));
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
else if (fmt[i] == 'E')
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
mark_referenced_regs (XVECEXP (x, i, j));
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
}
}
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
/* Insert a sequence of insns to restore. Place these insns in front of
CHAIN if BEFORE_P is nonzero, behind the insn otherwise. MAXRESTORE is
the maximum number of registers which should be restored during this call.
It should never be less than 1 since we only work with entire registers.
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
Note that we have verified in init_caller_save that we can do this
with a simple SET, so use it. Set INSN_CODE to what we save there
since the address might not be valid so the insn might not be recognized.
These insns will be reloaded and have register elimination done by
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
find_reload, so we need not worry about that here.
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
Return the extra number of registers saved. */
static int
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
insert_restore (chain, before_p, regno, maxrestore)
struct insn_chain *chain;
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
int before_p;
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
int regno;
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
int maxrestore;
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
{
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
int i;
c-lex.c (yylex): Initialize traditional_type, ansi_type and type. * c-lex.c (yylex): Initialize traditional_type, ansi_type and type. * caller-save.c (insert_save_restore): Initialize pat, code and numregs. * emit-rtl.c (push_to_sequence): Initialize top. (push_topmost_sequence): Likewise. * genattrtab.c (simplify_by_exploding): Initialize defval. * profile.c (branch_prob): Initialize dest. * rtl.h (note_stores): Remove duplicate prototype. (GEN_INT): Re-instate cast of second arg to HOST_WIDE_INT. Fix some warnings. * cplus-dem.c (gnu_special): Don't get confused by .<digits> strings that are not actually lengths. A change from libiberty that didn't make it into the gcc copy. From-SVN: r18942
1998-04-02 01:18:11 +02:00
rtx pat = NULL_RTX;
enum insn_code code = CODE_FOR_nothing;
int numregs = 0;
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
*** empty log message *** From-SVN: r676
1992-04-04 02:22:29 +02:00
/* A common failure mode if register status is not correct in the RTL
is for this routine to be called with a REGNO we didn't expect to
save. That will cause us to write an insn with a (nil) SET_DEST
or SET_SRC. Instead of doing so and causing a crash later, check
for this common case and abort here instead. This will remove one
step in debugging such problems. */
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
if (regno_save_mem[regno][1] == 0)
*** empty log message *** From-SVN: r676
1992-04-04 02:22:29 +02:00
abort ();
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
/* Get the pattern to emit and update our status.
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
See if we can restore `maxrestore' registers at once. Work
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
backwards to the single register case. */
for (i = maxrestore; i > 0; i--)
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
{
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
int j, k;
int ok = 1;
if (regno_save_mem[regno][i] == 0)
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
continue;
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
for (j = 0; j < i; j++)
if (! TEST_HARD_REG_BIT (hard_regs_saved, regno + j))
{
ok = 0;
break;
}
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
/* Must do this one restore at a time */
if (! ok)
continue;
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
pat = gen_rtx_SET (VOIDmode,
gen_rtx_REG (GET_MODE (regno_save_mem[regno][i]),
regno),
regno_save_mem[regno][i]);
code = reg_restore_code[regno][i];
/* Clear status for all registers we restored. */
for (k = 0; k < i; k++)
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
{
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
CLEAR_HARD_REG_BIT (hard_regs_saved, regno + k);
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
n_regs_saved--;
}
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
numregs = i;
break;
}
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
insert_one_insn (chain, before_p, code, pat);
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
/* Tell our callers how many extra registers we saved/restored */
return numregs - 1;
}
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
/* Like insert_restore above, but save registers instead. */
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
static int
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
insert_save (chain, before_p, regno, to_save)
struct insn_chain *chain;
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
int before_p;
int regno;
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
HARD_REG_SET *to_save;
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
{
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
int i;
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
rtx pat = NULL_RTX;
enum insn_code code = CODE_FOR_nothing;
int numregs = 0;
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
/* A common failure mode if register status is not correct in the RTL
is for this routine to be called with a REGNO we didn't expect to
save. That will cause us to write an insn with a (nil) SET_DEST
or SET_SRC. Instead of doing so and causing a crash later, check
for this common case and abort here instead. This will remove one
step in debugging such problems. */
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
if (regno_save_mem[regno][1] == 0)
abort ();
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
/* Get the pattern to emit and update our status.
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
See if we can save several registers with a single instruction.
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
Work backwards to the single register case. */
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
for (i = MOVE_MAX_WORDS; i > 0; i--)
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
{
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
int j, k;
int ok = 1;
if (regno_save_mem[regno][i] == 0)
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
continue;
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
for (j = 0; j < i; j++)
if (! TEST_HARD_REG_BIT (*to_save, regno + j))
{
ok = 0;
break;
}
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
/* Must do this one save at a time */
if (! ok)
continue;
pat = gen_rtx_SET (VOIDmode, regno_save_mem[regno][i],
gen_rtx_REG (GET_MODE (regno_save_mem[regno][i]),
regno));
code = reg_save_code[regno][i];
/* Set hard_regs_saved for all the registers we saved. */
for (k = 0; k < i; k++)
{
SET_HARD_REG_BIT (hard_regs_saved, regno + k);
n_regs_saved++;
}
numregs = i;
break;
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
}
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
insert_one_insn (chain, before_p, code, pat);
Major rework to have caller-saves emit load/store double insns when... Major rework to have caller-saves emit load/store double insns when possible and to avoid useless resaving of registers restored for source accesses only. * caller-save.c (toplevel): All arrays are multi-dimensional to hold information for multiple save/restore insns. New variable hard_regs_need_restore. (choose_hard_reg_mode): New argument `nregs' indicating how many hard registers are desired. All callers changed. (init_caller_save): Change initialization to handle multiple register saves. A call-used register can not be live across if we can not find a single register mode to save it in. (multiple register saves are optional) (init_save_areas): Change initialization of regno_save_mem to handle multiple register saves. (setup_save_areas): Allocate space for consecutive hard registers in aligned consecutive memory locations. When allocating space for consecutive hard registers, also initialize regno_save_mem for each hard register stored as a single word. (save_call_clobbered_regs): Initialize hard_regs_need_restore. Set hard_regs_need_restore to hard_regs_saved after crossing a call. Also recompute n_regs_saved. At the end of a basic block we need only restore registers in hard_regs_need_restore. (set_reg_live, clear_reg_live): Do the right thing for hard_regs_need_restore and hard_regs_saved. (restore_referenced_regs): Just return if X is a clobber. Test hard_regs_need_restore to determine when to restore a hard register from the save area. (insert_save_restore): Now returns the number of extra registers saved/restored. New argument `maxrestore' which constrains how many hard registers should be restored. All callers changed. Do stores of consecutive registers with double store insns if possible. Else do them with single word insns. Likewise for loads, except constrained by maxrestore. Set hard_regs_saved and hard_regs_need_restore appropriately to minimize useless saves into the save area. Test against hard_regs_need_restore when trying to restore multiple regs and similarly test against hard_regs_saved when storing multiple regs. From-SVN: r1964
1992-08-26 21:41:20 +02:00
/* Tell our callers how many extra registers we saved/restored */
return numregs - 1;
Initial revision From-SVN: r308
1992-02-12 18:16:21 +01:00
}
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
/* Emit a new caller-save insn and set the code. */
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
static void
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
insert_one_insn (chain, before_p, code, pat)
struct insn_chain *chain;
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
int before_p;
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
enum insn_code code;
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
rtx pat;
{
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
rtx insn = chain->insn;
struct insn_chain *new;
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
#ifdef HAVE_cc0
/* If INSN references CC0, put our insns in front of the insn that sets
CC0. This is always safe, since the only way we could be passed an
insn that references CC0 is for a restore, and doing a restore earlier
isn't a problem. We do, however, assume here that CALL_INSNs don't
reference CC0. Guard against non-INSN's like CODE_LABEL. */
if ((GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN)
&& before_p
&& reg_referenced_p (cc0_rtx, PATTERN (insn)))
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
chain = chain->prev, insn = chain->insn;
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
#endif
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
new = new_insn_chain ();
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
if (before_p)
{
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
new->prev = chain->prev;
if (new->prev != 0)
new->prev->next = new;
else
reload_insn_chain = new;
chain->prev = new;
new->next = chain;
new->insn = emit_insn_before (pat, insn);
caller-save.c (insert_one_insn): Initialize the live_before and live_after register sets. ( * caller-save.c (insert_one_insn): Initialize the live_before and live_after register sets. From-SVN: r23789
1998-11-23 10:39:24 +01:00
/* ??? It would be nice if we could exclude the already / still saved
registers from the live sets. */
COPY_REG_SET (new->live_before, chain->live_before);
COPY_REG_SET (new->live_after, chain->live_before);
basic-block.h (basic_block_head): Rename to x_basic_block_head. * basic-block.h (basic_block_head): Rename to x_basic_block_head. (basic_block_end): Rename to x_basic_block_end. (BLOCK_HEAD, BLOCK_END): Update. * caller-save.c: Change basic_block_head/end references to BLOCK_HEAD/END. * combine.c, flow.c, function.c, gcse.c, global.c: Likewise. * graph.c, haifa-sched.c, local-alloc.c, regclass.c: Likewise. * regmove.c, reload1.c, reorg.c, sched.c: Likewise. From-SVN: r24622
1999-01-11 23:37:20 +01:00
if (chain->insn == BLOCK_HEAD (chain->block))
BLOCK_HEAD (chain->block) = new->insn;
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
}
else
{
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
new->next = chain->next;
if (new->next != 0)
new->next->prev = new;
chain->next = new;
new->prev = chain;
new->insn = emit_insn_after (pat, insn);
caller-save.c (insert_one_insn): Initialize the live_before and live_after register sets. ( * caller-save.c (insert_one_insn): Initialize the live_before and live_after register sets. From-SVN: r23789
1998-11-23 10:39:24 +01:00
/* ??? It would be nice if we could exclude the already / still saved
registers from the live sets, and observe REG_UNUSED notes. */
COPY_REG_SET (new->live_before, chain->live_after);
COPY_REG_SET (new->live_after, chain->live_after);
basic-block.h (basic_block_head): Rename to x_basic_block_head. * basic-block.h (basic_block_head): Rename to x_basic_block_head. (basic_block_end): Rename to x_basic_block_end. (BLOCK_HEAD, BLOCK_END): Update. * caller-save.c: Change basic_block_head/end references to BLOCK_HEAD/END. * combine.c, flow.c, function.c, gcse.c, global.c: Likewise. * graph.c, haifa-sched.c, local-alloc.c, regclass.c: Likewise. * regmove.c, reload1.c, reorg.c, sched.c: Likewise. From-SVN: r24622
1999-01-11 23:37:20 +01:00
if (chain->insn == BLOCK_END (chain->block))
BLOCK_END (chain->block) = new->insn;
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
}
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
new->block = chain->block;
new->is_caller_save_insn = 1;
caller-save.c (restore_referenced_regs): Lose mode argument. * caller-save.c (restore_referenced_regs): Lose mode argument. (insert_save): Lose mode argument. (insert_restore): Lose mode argument. (insert_one_insn): Lose mode argument. (save_call_clobbered_regs): Lose mode argument. (setup_save_areas): Take no argument and return void. All callers changed. Don't verify validity of memory addresses. * reload.h (setup_save_ares): Adjust prototype. (save_call_clobbered_regs): Likewise. * reload1.c (delete_caller_save_insns): New function. (caller_save_spill_class): Delete variable. (caller_save_group_size): Delete variable. (reload): Call setup_save_areas and save_call_clobbered_regs in the main loop, before calling calculate_needs_all_insns. Don't call save_call_clobbered_regs after the loop. Call delete_caller_save_insns at the end of an iteration if something changed. Delete code to manage caller_save_spill_class. Emit the final note before setting reload_first_uid. Simplify test that determines whether reload_as_needed gets run. (calculate_needs): Delete code to manage caller_save_spill_class. From-SVN: r22876
1998-10-07 02:13:49 +02:00
reload.h (compute_use_by_pseudos): Declare. * reload.h (compute_use_by_pseudos): Declare. * reload1.c (spilled_pseudos, insns_need_reload): New variables. (something_needs_reloads): Delete variable. (finish_spills): New function. (compute_use_by_pseudos): New function. (delete_caller_save_insns): Lose argument FIRST. All callers changed. Use the reload_insn_chain instead of walking the rtl directly. (reload): Allocate and free spilled_pseudos. Ensure that all calls of spill_hard_reg are followed by a call to finish_spills. Use the insns_need_reload list instead of something_needs_reloads to find out if reload_as_needed must be called. Clear unused_insn_chains at the end. (calculate_needs_all_insns): Lose FIRST parameter. All callers changed. Delete code to keep track of current basic block. Walk reload_insn_chain instead of the rtl structure. Build the insns_need_reload chain. Remember which insns need reloading/elimination by setting the appropriate fields in struct insn_chain, not by putting modes on the insn. (calculate_needs): Lose THIS_BLOCK arg. Accept arg CHAIN instead of arg INSN. All callers changed. Delete declaration of struct needs. Don't set something_needs_reloads. Record insn needs in the CHAIN argument. (spill_hard_reg): Record the affected pseudos in spilled_pseudos. (reload_as_needed): Lose FIRST arg. All callers changed. Walk the reload_insn_chain instead of the rtx structure. Delete code to keep track of current basic block. Rename one of the NEXT variables to OLD_NEXT. (allocate_reload_reg): Accept arg CHAIN instead of arg INSN. All callers changed. (choose_reload_regs): Likewise. (emit_reload_insns): Replace INSN and BB args with arg CHAIN. All callers changed. * caller-save.c (MOVE_MAX_WORDS): New macro. Use it throughout instead of (MOVE_MAX / UNITS_PER_WORD) computation. (hard_regs_live, hard_regs_need_restore): Delete variables. (n_regs_saved): Now static. (referenced_regs, this_insn_sets): New variables. (setup_save_areas): Restructure the code a bit. (restore_referenced_regs): Delete function. (mark_referenced_regs): New function, similar to the old restore_referenced_regs, but mark registers in referenced_regs. (clear_reg_live): Delete function. (mark_set_regs): Renamed from set_reg_live. All callers changed. Only mark registers in this_insn_sets. (save_call_clobbered_regs): Rework this function to walk the reload_insn_chain instead of using the list of instructions directly. Delete code to keep track of register lives, compute live regs on the fly from information in the chain. Instead of calling restore_referenced_regs, use mark_referenced_regs, then walk the set it computes and call insert_restore as appropriate. (insert_restore): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Restructure the code a bit. Test hard_regs_saved instead of hard_regs_need_restore. (insert_save): Lose INSN and BLOCK args. Add CHAIN and TO_SAVE args. All callers changed. Restructure the code a bit. Use TO_SAVE to determine which regs to save instead of more complicated test. (insert_one_arg): Lose INSN and BLOCK args. Add CHAIN arg. All callers changed. Create a new insn_chain structure for the new insn and place it into the chain. * rtl.texi: Update documentation to reflect that reload no longer puts modes on the insns. From-SVN: r23074
1998-10-14 03:14:42 +02:00
INSN_CODE (new->insn) = code;
caller-save.c (insert_save_restore): Break this function up into new functions insert_restore... � * caller-save.c (insert_save_restore): Break this function up into new functions insert_restore, insert_save and insert_one_insn. All callers changed. (insert_restore): New function, mostly broken out of insert_save_restore. (insert_save): Likewise. (insert_one_insn): Likewise. (restore_referenced_regs): New argument BLOCK. All callers changed. (save_call_clobbered_regs): Don't keep track of basic block boundaries in this function, do it in insert_one_insn instead. From-SVN: r22754
1998-10-02 12:25:57 +02:00
}
Reference in New Issue Copy Permalink