/* 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, 2005 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.
GCC 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
+Software Foundation; either version 3, or (at your option) any later
version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
for more details.
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, 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301, USA. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
#include "config.h"
#include "system.h"
#include "toplev.h"
#include "tm_p.h"
#include "addresses.h"
+#include "df.h"
+#include "ggc.h"
#ifndef MAX_MOVE_MAX
#define MAX_MOVE_MAX MOVE_MAX
be recognized. */
static int
- reg_save_code[FIRST_PSEUDO_REGISTER][MAX_MACHINE_MODE];
+ cached_reg_save_code[FIRST_PSEUDO_REGISTER][MAX_MACHINE_MODE];
static int
- reg_restore_code[FIRST_PSEUDO_REGISTER][MAX_MACHINE_MODE];
+ cached_reg_restore_code[FIRST_PSEUDO_REGISTER][MAX_MACHINE_MODE];
/* Set of hard regs currently residing in save area (during insn scan). */
static HARD_REG_SET referenced_regs;
-static void mark_set_regs (rtx, rtx, void *);
+static void mark_set_regs (rtx, const_rtx, void *);
static void mark_referenced_regs (rtx);
static int insert_save (struct insn_chain *, int, int, HARD_REG_SET *,
enum machine_mode *);
enum machine_mode *);
static struct insn_chain *insert_one_insn (struct insn_chain *, int, int,
rtx);
-static void add_stored_regs (rtx, rtx, void *);
+static void add_stored_regs (rtx, const_rtx, void *);
+\f
+static GTY(()) rtx savepat;
+static GTY(()) rtx restpat;
+static GTY(()) rtx test_reg;
+static GTY(()) rtx test_mem;
+static GTY(()) rtx saveinsn;
+static GTY(()) rtx restinsn;
+
+/* Return the INSN_CODE used to save register REG in mode MODE. */
+static int
+reg_save_code (int reg, enum machine_mode mode)
+{
+ bool ok;
+ if (cached_reg_save_code[reg][mode])
+ return cached_reg_save_code[reg][mode];
+ if (!HARD_REGNO_MODE_OK (reg, mode))
+ {
+ cached_reg_save_code[reg][mode] = -1;
+ cached_reg_restore_code[reg][mode] = -1;
+ return -1;
+ }
+
+ /* Update the register number and modes of the register
+ and memory operand. */
+ SET_REGNO (test_reg, reg);
+ PUT_MODE (test_reg, mode);
+ PUT_MODE (test_mem, mode);
+
+ /* Force re-recognition of the modified insns. */
+ INSN_CODE (saveinsn) = -1;
+ INSN_CODE (restinsn) = -1;
+
+ cached_reg_save_code[reg][mode] = recog_memoized (saveinsn);
+ cached_reg_restore_code[reg][mode] = recog_memoized (restinsn);
+
+ /* Now extract both insns and see if we can meet their
+ constraints. */
+ ok = (cached_reg_save_code[reg][mode] != -1
+ && cached_reg_restore_code[reg][mode] != -1);
+ if (ok)
+ {
+ extract_insn (saveinsn);
+ ok = constrain_operands (1);
+ extract_insn (restinsn);
+ ok &= constrain_operands (1);
+ }
+
+ if (! ok)
+ {
+ cached_reg_save_code[reg][mode] = -1;
+ cached_reg_restore_code[reg][mode] = -1;
+ }
+ gcc_assert (cached_reg_save_code[reg][mode]);
+ return cached_reg_save_code[reg][mode];
+}
+
+/* Return the INSN_CODE used to restore register REG in mode MODE. */
+static int
+reg_restore_code (int reg, enum machine_mode mode)
+{
+ if (cached_reg_restore_code[reg][mode])
+ return cached_reg_restore_code[reg][mode];
+ /* Populate our cache. */
+ reg_save_code (reg, mode);
+ return cached_reg_restore_code[reg][mode];
+}
\f
/* Initialize for caller-save.
int offset;
rtx address;
int i, j;
- enum machine_mode mode;
- rtx savepat, restpat;
- rtx test_reg, test_mem;
- rtx saveinsn, restinsn;
/* 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,
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);
-
- 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;
- PUT_MODE (test_reg, mode);
- PUT_MODE (test_mem, mode);
-
- /* Force re-recognition of the modified insns. */
- INSN_CODE (saveinsn) = -1;
- INSN_CODE (restinsn) = -1;
-
- reg_save_code[i][mode] = recog_memoized (saveinsn);
- reg_restore_code[i][mode] = recog_memoized (restinsn);
-
- /* Now extract both insns and see if we can meet their
- constraints. */
- ok = (reg_save_code[i][mode] != -1
- && reg_restore_code[i][mode] != -1);
- if (ok)
- {
- extract_insn (saveinsn);
- ok = constrain_operands (1);
- extract_insn (restinsn);
- ok &= constrain_operands (1);
- }
-
- if (! ok)
- {
- reg_save_code[i][mode] = -1;
- reg_restore_code[i][mode] = -1;
- }
- }
- else
- {
- reg_save_code[i][mode] = -1;
- reg_restore_code[i][mode] = -1;
- }
+ 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 (j = 1; j <= MOVE_MAX_WORDS; j++)
- if (reg_save_code [i][regno_save_mode[i][j]] == -1)
+ if (reg_save_code (i,regno_save_mode[i][j]) == -1)
{
regno_save_mode[i][j] = VOIDmode;
if (j == 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])
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;
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, &this_insn_sets);
- /* Sibcalls are considered to set the return value,
- compare flow.c:propagate_one_insn. */
- if (SIBLING_CALL_P (insn) && current_function_return_rtx)
- mark_set_regs (current_function_return_rtx, NULL_RTX,
- &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);
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)
+mark_set_regs (rtx reg, const_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)
&& REGNO (reg) < FIRST_PSEUDO_REGISTER)
{
regno = REGNO (reg);
- endregno = regno + hard_regno_nregs[regno][mode];
+ endregno = END_HARD_REGNO (reg);
}
else
return;
been assigned hard regs have had their register number changed already,
so we can ignore pseudos. */
static void
-add_stored_regs (rtx reg, rtx setter, void *data)
+add_stored_regs (rtx reg, const_rtx setter, void *data)
{
int regno, endregno, i;
enum machine_mode mode = GET_MODE (reg);
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 (reg) + offset;
+ regno = REGNO (SUBREG_REG (reg)) + offset;
endregno = regno + subreg_nregs (reg);
}
else
return;
regno = REGNO (reg) + offset;
- endregno = regno + hard_regno_nregs[regno][mode];
+ endregno = end_hard_regno (mode, regno);
}
for (i = regno; i < endregno; 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. */
pat = gen_rtx_SET (VOIDmode,
gen_rtx_REG (GET_MODE (mem),
regno), mem);
- code = reg_restore_code[regno][GET_MODE (mem)];
+ code = reg_restore_code (regno, GET_MODE (mem));
new = insert_one_insn (chain, before_p, code, pat);
/* Clear status for all registers we restored. */
pat = gen_rtx_SET (VOIDmode, mem,
gen_rtx_REG (GET_MODE (mem),
regno));
- code = reg_save_code[regno][GET_MODE (mem)];
+ code = reg_save_code (regno, GET_MODE (mem));
new = insert_one_insn (chain, before_p, code, pat);
/* Set hard_regs_saved and dead_or_set for all the registers we saved. */
INSN_CODE (new->insn) = code;
return new;
}
+#include "gt-caller-save.h"
OSDN Git Service
