/* Move registers around to reduce number of move instructions needed.
- Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
- 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
+ Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
+ 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
Free Software Foundation, Inc.
This file is part of GCC.
#include "system.h"
#include "coretypes.h"
#include "tm.h"
-#include "rtl.h" /* stdio.h must precede rtl.h for FFS. */
+#include "rtl.h"
#include "tm_p.h"
#include "insn-config.h"
#include "recog.h"
+#include "target.h"
#include "output.h"
#include "regs.h"
#include "hard-reg-set.h"
#include "expr.h"
#include "basic-block.h"
#include "except.h"
-#include "toplev.h"
+#include "diagnostic-core.h"
#include "reload.h"
#include "timevar.h"
#include "tree-pass.h"
#include "df.h"
+#include "ira.h"
static int optimize_reg_copy_1 (rtx, rtx, rtx);
static void optimize_reg_copy_2 (rtx, rtx, rtx);
/* Return nonzero if registers with CLASS1 and CLASS2 can be merged without
causing too much register allocation problems. */
static int
-regclass_compatible_p (enum reg_class class0, enum reg_class class1)
+regclass_compatible_p (reg_class_t class0, reg_class_t class1)
{
return (class0 == class1
|| (reg_class_subset_p (class0, class1)
- && ! CLASS_LIKELY_SPILLED_P (class0))
+ && ! targetm.class_likely_spilled_p (class0))
|| (reg_class_subset_p (class1, class0)
- && ! CLASS_LIKELY_SPILLED_P (class1)));
+ && ! targetm.class_likely_spilled_p (class1)));
}
\f
if (code == MEM && GET_CODE (XEXP (x, 0)) == PLUS
&& XEXP (XEXP (x, 0), 0) == reg
- && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
+ && CONST_INT_P (XEXP (XEXP (x, 0), 1))
&& INTVAL (XEXP (XEXP (x, 0), 1)) == plusconst)
return x;
&SET_SRC (inc_insn_set),
XEXP (SET_SRC (inc_insn_set), 0), 1);
validate_change (insn, &XEXP (use, 0),
- gen_rtx_fmt_e (inc_code, Pmode, reg), 1);
+ gen_rtx_fmt_e (inc_code,
+ GET_MODE (XEXP (use, 0)), reg),
+ 1);
if (apply_change_group ())
{
/* If there is a REG_DEAD note on this insn, we must
/* We don't want to mess with hard regs if register classes are small. */
if (sregno == dregno
- || (SMALL_REGISTER_CLASSES
+ || (targetm.small_register_classes_for_mode_p (GET_MODE (src))
&& (sregno < FIRST_PSEUDO_REGISTER
|| dregno < FIRST_PSEUDO_REGISTER))
/* We don't see all updates to SP if they are in an auto-inc memory
if (sregno < FIRST_PSEUDO_REGISTER
&& reg_mentioned_p (dest, PATTERN (q)))
failed = 1;
-
+
/* Attempt to replace all uses. */
else if (!validate_replace_rtx (src, dest, q))
failed = 1;
/* For SREGNO, count the total number of insns scanned.
For DREGNO, count the total number of insns scanned after
passing the death note for DREGNO. */
- s_length++;
- if (dest_death)
- d_length++;
+ if (!DEBUG_INSN_P (p))
+ {
+ s_length++;
+ if (dest_death)
+ d_length++;
+ }
/* If the insn in which SRC dies is a CALL_INSN, don't count it
as a call that has been crossed. Otherwise, count it. */
rtx src_reg = XEXP (src, 0);
int src_no = REGNO (src_reg);
int dst_no = REGNO (dest);
- rtx p, set;
+ rtx p, set, set_insn;
enum machine_mode old_mode;
basic_block bb = BLOCK_FOR_INSN (insn);
for (p = PREV_INSN (insn); p && ! reg_set_p (src_reg, p); p = PREV_INSN (p))
if (INSN_P (p) && BLOCK_FOR_INSN (p) != bb)
break;
-
+
if (! p || BLOCK_FOR_INSN (p) != bb)
return;
/* Do not use a SUBREG to truncate from one mode to another if truncation
is not a nop. */
if (GET_MODE_BITSIZE (GET_MODE (src_reg)) <= GET_MODE_BITSIZE (GET_MODE (src))
- && !TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (GET_MODE (src)),
- GET_MODE_BITSIZE (GET_MODE (src_reg))))
+ && !TRULY_NOOP_TRUNCATION_MODES_P (GET_MODE (src), GET_MODE (src_reg)))
return;
+ set_insn = p;
old_mode = GET_MODE (src_reg);
PUT_MODE (src_reg, GET_MODE (src));
XEXP (src, 0) = SET_SRC (set);
}
else
{
- rtx note = find_reg_note (p, REG_EQUAL, NULL_RTX);
+ rtx note = find_reg_note (set_insn, REG_EQUAL, NULL_RTX);
if (note)
- remove_note (p, note);
+ {
+ if (rtx_equal_p (XEXP (note, 0), XEXP (src, 0)))
+ {
+ XEXP (note, 0)
+ = gen_rtx_fmt_e (GET_CODE (src), GET_MODE (src),
+ XEXP (note, 0));
+ df_notes_rescan (set_insn);
+ }
+ else
+ remove_note (set_insn, note);
+ }
}
}
rtx *p_move_notes;
int src_regno;
int dest_regno;
- int insn_uid;
- int move_uid;
/* A REG_LIVE_LENGTH of -1 indicates the register is equivalent to a constant
or memory location and is used infrequently; a REG_LIVE_LENGTH of -2 is
*p_move_notes = NULL_RTX;
*p_insn_notes = NULL_RTX;
- insn_uid = INSN_UID (insn);
- move_uid = INSN_UID (move_insn);
-
/* Update the various register tables. */
dest_regno = REGNO (dest);
INC_REG_N_SETS (dest_regno, 1);
if (find_regno_note (p, REG_DEAD, REGNO (dst)))
dst_death = p;
- if (! dst_death)
+ if (! dst_death && !DEBUG_INSN_P (p))
length++;
pset = single_set (p);
if (pset && SET_DEST (pset) == dst
&& GET_CODE (SET_SRC (pset)) == PLUS
&& XEXP (SET_SRC (pset), 0) == src
- && GET_CODE (XEXP (SET_SRC (pset), 1)) == CONST_INT)
+ && CONST_INT_P (XEXP (SET_SRC (pset), 1)))
{
HOST_WIDE_INT newconst
= INTVAL (offset) - INTVAL (XEXP (SET_SRC (pset), 1));
if (REG_N_CALLS_CROSSED (REGNO (src)) == 0)
break;
- if (call_used_regs [REGNO (dst)]
+ if ((HARD_REGISTER_P (dst) && call_used_regs [REGNO (dst)])
|| find_reg_fusage (p, CLOBBER, dst))
break;
}
FOR_EACH_BB_REVERSE (bb)
{
/* ??? Use the safe iterator because fixup_match_2 can remove
- insns via try_auto_increment. */
+ insns via try_auto_increment. */
FOR_BB_INSNS_REVERSE_SAFE (bb, insn, prev)
{
struct match match;
if (REGNO (src) < FIRST_PSEUDO_REGISTER)
{
if (GET_CODE (SET_SRC (set)) == PLUS
- && GET_CODE (XEXP (SET_SRC (set), 1)) == CONST_INT
+ && CONST_INT_P (XEXP (SET_SRC (set), 1))
&& XEXP (SET_SRC (set), 0) == src
&& fixup_match_2 (insn, dst, src,
XEXP (SET_SRC (set), 1)))
if (BLOCK_FOR_INSN (p) != bb)
break;
- length++;
+ if (!DEBUG_INSN_P (p))
+ length++;
/* ??? See if all of SRC is set in P. This test is much
more conservative than it needs to be. */
if (pset && SET_DEST (pset) == src)
{
/* We use validate_replace_rtx, in case there
- are multiple identical source operands. All of
- them have to be changed at the same time. */
+ are multiple identical source operands. All
+ of them have to be changed at the same time:
+ when validate_replace_rtx() calls
+ apply_change_group(). */
+ validate_change (p, &SET_DEST (pset), dst, 1);
if (validate_replace_rtx (src, dst, insn))
- {
- if (validate_change (p, &SET_DEST (pset),
- dst, 0))
- success = 1;
- else
- {
- /* Change all source operands back.
- This modifies the dst as a side-effect. */
- validate_replace_rtx (dst, src, insn);
- /* Now make sure the dst is right. */
- validate_change (insn,
- recog_data.operand_loc[match_no],
- dst, 0);
- }
- }
+ success = 1;
break;
}
- /* We can't make this change if SRC is read or
+ /* We can't make this change if DST is mentioned at
+ all in P, since we are going to change its value.
+ We can't make this change if SRC is read or
partially written in P, since we are going to
- eliminate SRC. We can't make this change
- if DST is mentioned at all in P,
- since we are going to change its value. */
- if (reg_overlap_mentioned_p (src, PATTERN (p))
- || reg_mentioned_p (dst, PATTERN (p)))
- break;
+ eliminate SRC. However, if it's a debug insn, we
+ can't refrain from making the change, for this
+ would cause codegen differences, so instead we
+ invalidate debug expressions that reference DST,
+ and adjust references to SRC in them so that they
+ become references to DST. */
+ if (reg_mentioned_p (dst, PATTERN (p)))
+ {
+ if (DEBUG_INSN_P (p))
+ validate_change (p, &INSN_VAR_LOCATION_LOC (p),
+ gen_rtx_UNKNOWN_VAR_LOC (), 1);
+ else
+ break;
+ }
+ if (reg_overlap_mentioned_p (src, PATTERN (p)))
+ {
+ if (DEBUG_INSN_P (p))
+ validate_replace_rtx_group (src, dst, p);
+ else
+ break;
+ }
/* If we have passed a call instruction, and the
pseudo-reg DST is not already live across a call,
break;
}
+ else if (num_changes_pending () > 0)
+ cancel_changes (0);
}
/* If we weren't able to replace any of the alternatives, try an
regstat_init_n_sets_and_refs ();
regstat_compute_ri ();
+ if (flag_ira_loop_pressure)
+ ira_set_pseudo_classes (dump_file);
+
regno_src_regno = XNEWVEC (int, nregs);
for (i = nregs; --i >= 0; )
regno_src_regno[i] = -1;
}
regstat_free_n_sets_and_refs ();
regstat_free_ri ();
+ if (flag_ira_loop_pressure)
+ free_reg_info ();
return 0;
}
case 'j': case 'k': case 'l': case 'p': case 'q': case 't': case 'u':
case 'v': case 'w': case 'x': case 'y': case 'z': case 'A': case 'B':
case 'C': case 'D': case 'W': case 'Y': case 'Z':
- if (CLASS_LIKELY_SPILLED_P (REG_CLASS_FROM_CONSTRAINT ((unsigned char) c, p) ))
+ if (targetm.class_likely_spilled_p (REG_CLASS_FROM_CONSTRAINT ((unsigned char) c, p)))
likely_spilled[op_no] = 1;
break;
}
0, /* properties_destroyed */
0, /* todo_flags_start */
TODO_df_finish | TODO_verify_rtl_sharing |
- TODO_dump_func |
TODO_ggc_collect /* todo_flags_finish */
}
};
OSDN Git Service
