/* Save and restore call-clobbered registers which are live across a call.
- Copyright (C) 1989, 1992, 1994, 1995, 1997, 1998,
- 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+ Copyright (C) 1989, 1992, 1994, 1995, 1997, 1998, 1999, 2000,
+ 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
This file is part of GCC.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA. */
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA. */
#include "config.h"
#include "system.h"
#include "expr.h"
#include "toplev.h"
#include "tm_p.h"
+#include "addresses.h"
+#include "df.h"
#ifndef MAX_MOVE_MAX
#define MAX_MOVE_MAX MOVE_MAX
insn. */
static HARD_REG_SET referenced_regs;
-/* Computed in mark_set_regs, holds all registers set by the current
- instruction. */
-static HARD_REG_SET this_insn_sets;
-
static void mark_set_regs (rtx, rtx, void *);
static void mark_referenced_regs (rtx);
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
if (TEST_HARD_REG_BIT
(reg_class_contents
- [(int) MODE_BASE_REG_CLASS (regno_save_mode [i][1])], i))
+ [(int) base_reg_class (regno_save_mode [i][1], PLUS, CONST_INT)], i))
break;
gcc_assert (i < FIRST_PSEUDO_REGISTER);
savepat = gen_rtx_SET (VOIDmode, test_mem, test_reg);
restpat = gen_rtx_SET (VOIDmode, test_reg, test_mem);
- saveinsn = gen_rtx_INSN (VOIDmode, 0, 0, 0, 0, 0, savepat, -1, 0, 0);
- restinsn = gen_rtx_INSN (VOIDmode, 0, 0, 0, 0, 0, restpat, -1, 0, 0);
+ saveinsn = gen_rtx_INSN (VOIDmode, 0, 0, 0, 0, 0, savepat, -1, 0);
+ restinsn = gen_rtx_INSN (VOIDmode, 0, 0, 0, 0, 0, restpat, -1, 0);
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
for (mode = 0 ; mode < MAX_MACHINE_MODE; mode++)
if (HARD_REGNO_MODE_OK (i, mode))
- {
+ {
int ok;
/* Update the register number and modes of the register
and memory operand. */
- REGNO (test_reg) = i;
+ SET_REGNO (test_reg, i);
PUT_MODE (test_reg, mode);
PUT_MODE (test_mem, mode);
reg_restore_code[i][mode] = recog_memoized (restinsn);
/* Now extract both insns and see if we can meet their
- constraints. */
+ constraints. */
ok = (reg_save_code[i][mode] != -1
&& reg_restore_code[i][mode] != -1);
if (ok)
reg_save_code[i][mode] = -1;
reg_restore_code[i][mode] = -1;
}
- }
+ }
else
{
reg_save_code[i][mode] = -1;
{
unsigned int regno = reg_renumber[i];
unsigned int endregno
- = regno + hard_regno_nregs[regno][GET_MODE (regno_reg_rtx[i])];
+ = end_hard_regno (GET_MODE (regno_reg_rtx[i]), regno);
for (r = regno; r < endregno; r++)
if (call_used_regs[r])
struct insn_chain *chain, *next;
enum machine_mode save_mode [FIRST_PSEUDO_REGISTER];
+ /* Computed in mark_set_regs, holds all registers set by the current
+ instruction. */
+ HARD_REG_SET this_insn_sets;
+
CLEAR_HARD_REG_SET (hard_regs_saved);
n_regs_saved = 0;
regno += insert_restore (chain, 1, regno, MOVE_MAX_WORDS, save_mode);
}
- if (code == CALL_INSN && ! find_reg_note (insn, REG_NORETURN, NULL))
+ if (code == CALL_INSN
+ && ! SIBLING_CALL_P (insn)
+ && ! find_reg_note (insn, REG_NORETURN, NULL))
{
unsigned regno;
HARD_REG_SET hard_regs_to_save;
multi-hard-reg pseudo; then the pseudo is considered live
during the call, but the subreg that is set isn't. */
CLEAR_HARD_REG_SET (this_insn_sets);
- note_stores (PATTERN (insn), mark_set_regs, NULL);
+ note_stores (PATTERN (insn), mark_set_regs, &this_insn_sets);
/* Compute which hard regs must be saved before this call. */
AND_COMPL_HARD_REG_SET (hard_regs_to_save, call_fixed_reg_set);
}
}
-/* Here from note_stores when an insn stores a value in a register.
+/* Here from note_stores, or directly from save_call_clobbered_regs, when
+ an insn stores a value in a register.
Set the proper bit or bits in this_insn_sets. All pseudos that have
been assigned hard regs have had their register number changed already,
so we can ignore pseudos. */
static void
-mark_set_regs (rtx reg, rtx setter ATTRIBUTE_UNUSED,
- void *data ATTRIBUTE_UNUSED)
+mark_set_regs (rtx reg, rtx setter ATTRIBUTE_UNUSED, void *data)
{
int regno, endregno, i;
- enum machine_mode mode = GET_MODE (reg);
+ HARD_REG_SET *this_insn_sets = data;
if (GET_CODE (reg) == SUBREG)
{
if (!REG_P (inner) || REGNO (inner) >= FIRST_PSEUDO_REGISTER)
return;
regno = subreg_regno (reg);
+ endregno = regno + subreg_nregs (reg);
}
else if (REG_P (reg)
&& REGNO (reg) < FIRST_PSEUDO_REGISTER)
- regno = REGNO (reg);
+ {
+ regno = REGNO (reg);
+ endregno = END_HARD_REGNO (reg);
+ }
else
return;
- endregno = regno + hard_regno_nregs[regno][mode];
-
for (i = regno; i < endregno; i++)
- SET_HARD_REG_BIT (this_insn_sets, i);
+ SET_HARD_REG_BIT (*this_insn_sets, i);
}
/* Here from note_stores when an insn stores a value in a register.
if (GET_CODE (setter) == CLOBBER)
return;
- if (GET_CODE (reg) == SUBREG && REG_P (SUBREG_REG (reg)))
+ if (GET_CODE (reg) == SUBREG
+ && REG_P (SUBREG_REG (reg))
+ && REGNO (SUBREG_REG (reg)) < FIRST_PSEUDO_REGISTER)
{
offset = subreg_regno_offset (REGNO (SUBREG_REG (reg)),
GET_MODE (SUBREG_REG (reg)),
SUBREG_BYTE (reg),
GET_MODE (reg));
- reg = SUBREG_REG (reg);
+ regno = REGNO (SUBREG_REG (reg)) + offset;
+ endregno = regno + subreg_nregs (reg);
}
+ else
+ {
+ if (!REG_P (reg) || REGNO (reg) >= FIRST_PSEUDO_REGISTER)
+ return;
- if (!REG_P (reg) || REGNO (reg) >= FIRST_PSEUDO_REGISTER)
- return;
-
- regno = REGNO (reg) + offset;
- endregno = regno + hard_regno_nregs[regno][mode];
+ regno = REGNO (reg) + offset;
+ endregno = end_hard_regno (mode, regno);
+ }
for (i = regno; i < endregno; i++)
SET_REGNO_REG_SET ((regset) data, i);
: reg_renumber[regno]);
if (hardregno >= 0)
- {
- int nregs = hard_regno_nregs[hardregno][GET_MODE (x)];
- while (nregs-- > 0)
- SET_HARD_REG_BIT (referenced_regs, hardregno + nregs);
- }
+ add_to_hard_reg_set (&referenced_regs, GET_MODE (x), hardregno);
/* 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. */
registers from the live sets, and observe REG_UNUSED notes. */
COPY_REG_SET (&new->live_throughout, &chain->live_throughout);
/* Registers that are set in CHAIN->INSN live in the new insn.
- (Unless there is a REG_UNUSED note for them, but we don't
+ (Unless there is a REG_UNUSED note for them, but we don't
look for them here.) */
note_stores (PATTERN (chain->insn), add_stored_regs,
&new->live_throughout);
OSDN Git Service
