Skip to content

R
riscv-gcc-1
Commit 184bb750 by J"orn Rennecke Committed by Jeff Law
Options

regmove.c: New implementation of regmove pass. 

        * regmove.c: New implementation of regmove pass.
        * local-alloc.c (optimize_reg_copy_1, optimize_reg_copy_2): Remove
        decls, make them have external linkage.  Return a value from
        optimize_reg_copy_1.
        * reload.h (count_occurrences): Add decl.
        * reload1.c (count_occurrences): Delete decl, make it have external
        linkage.
        * rtl.h (optimize_reg_copy_1, optimize_reg_copy_2): Declare.

Co-Authored-By: Jeffrey A Law <law@cygnus.com>

From-SVN: r17316
parent 9d194380
Showing with 954 additions and 511 deletions
gcc/ChangeLog
Sat Jan 10 21:50:16 1998 J"orn Rennecke <amylaar@cygnus.co.uk>
Jeffrey A Law (law@cygnus.com)
* regmove.c: New implementation of regmove pass.
* local-alloc.c (optimize_reg_copy_1, optimize_reg_copy_2): Remove
decls, make them have external linkage. Return a value from
optimize_reg_copy_1.
* reload.h (count_occurrences): Add decl.
* reload1.c (count_occurrences): Delete decl, make it have external
linkage.
* rtl.h (optimize_reg_copy_1, optimize_reg_copy_2): Declare.
Sat Jan 10 20:30:12 1998 Jeffrey A Law (law@cygnus.com) Sat Jan 10 20:30:12 1998 Jeffrey A Law (law@cygnus.com)
* regclass.c (record_address_regs): Don't use REG_OK_FOR_BASE_P * regclass.c (record_address_regs): Don't use REG_OK_FOR_BASE_P
......
gcc/local-alloc.c
/* Allocate registers within a basic block, for GNU compiler. /* Allocate registers within a basic block, for GNU compiler.
Copyright (C) 1987, 88, 91, 93-6, 1997 Free Software Foundation, Inc. Copyright (C) 1987, 88, 91, 93-97, 1998 Free Software Foundation, Inc.
This file is part of GNU CC. This file is part of GNU CC.
...@@ -249,8 +249,6 @@ static int validate_equiv_mem PROTO((rtx, rtx, rtx)); ...@@ -249,8 +249,6 @@ static int validate_equiv_mem PROTO((rtx, rtx, rtx));
static int contains_replace_regs PROTO((rtx, char *)); static int contains_replace_regs PROTO((rtx, char *));
static int memref_referenced_p PROTO((rtx, rtx)); static int memref_referenced_p PROTO((rtx, rtx));
static int memref_used_between_p PROTO((rtx, rtx, rtx)); static int memref_used_between_p PROTO((rtx, rtx, rtx));
static void optimize_reg_copy_1 PROTO((rtx, rtx, rtx));
static void optimize_reg_copy_2 PROTO((rtx, rtx, rtx));
static void update_equiv_regs PROTO((void)); static void update_equiv_regs PROTO((void));
static void block_alloc PROTO((int)); static void block_alloc PROTO((int));
static int qty_sugg_compare PROTO((int, int)); static int qty_sugg_compare PROTO((int, int));
...@@ -752,7 +750,7 @@ memref_used_between_p (memref, start, end) ...@@ -752,7 +750,7 @@ memref_used_between_p (memref, start, end)
DEST to be tied to SRC, thus often saving one register in addition to a DEST to be tied to SRC, thus often saving one register in addition to a
register-register copy. */ register-register copy. */
static void int
optimize_reg_copy_1 (insn, dest, src) optimize_reg_copy_1 (insn, dest, src)
rtx insn; rtx insn;
rtx dest; rtx dest;
...@@ -764,15 +762,15 @@ optimize_reg_copy_1 (insn, dest, src) ...@@ -764,15 +762,15 @@ optimize_reg_copy_1 (insn, dest, src)
int sregno = REGNO (src); int sregno = REGNO (src);
int dregno = REGNO (dest); int dregno = REGNO (dest);
/* We don't want to mess with hard regs if register classes are small. */
if (sregno == dregno if (sregno == dregno
/* We don't want to mess with hard regs if register classes are small. */
|| (SMALL_REGISTER_CLASSES || (SMALL_REGISTER_CLASSES
&& (sregno < FIRST_PSEUDO_REGISTER && (sregno < FIRST_PSEUDO_REGISTER
|| dregno < FIRST_PSEUDO_REGISTER)) || dregno < FIRST_PSEUDO_REGISTER))
/* We don't see all updates to SP if they are in an auto-inc memory /* We don't see all updates to SP if they are in an auto-inc memory
reference, so we must disallow this optimization on them. */ reference, so we must disallow this optimization on them. */
|| sregno == STACK_POINTER_REGNUM || dregno == STACK_POINTER_REGNUM) || sregno == STACK_POINTER_REGNUM || dregno == STACK_POINTER_REGNUM)
return; return 0;
for (p = NEXT_INSN (insn); p; p = NEXT_INSN (p)) for (p = NEXT_INSN (insn); p; p = NEXT_INSN (p))
{ {
...@@ -864,10 +862,14 @@ optimize_reg_copy_1 (insn, dest, src) ...@@ -864,10 +862,14 @@ optimize_reg_copy_1 (insn, dest, src)
later. Make sure ALL of DEST dies here; again, this is later. Make sure ALL of DEST dies here; again, this is
overly conservative. */ overly conservative. */
if (dest_death == 0 if (dest_death == 0
&& (dest_death = find_regno_note (q, REG_DEAD, dregno)) != 0 && (dest_death = find_regno_note (q, REG_DEAD, dregno)) != 0)
&& GET_MODE (XEXP (dest_death, 0)) == GET_MODE (dest)) {
if (GET_MODE (XEXP (dest_death, 0)) != GET_MODE (dest))
failed = 1, dest_death = 0;
else
remove_note (q, dest_death); remove_note (q, dest_death);
} }
}
if (! failed) if (! failed)
{ {
...@@ -876,7 +878,7 @@ optimize_reg_copy_1 (insn, dest, src) ...@@ -876,7 +878,7 @@ optimize_reg_copy_1 (insn, dest, src)
if (REG_LIVE_LENGTH (sregno) >= 0) if (REG_LIVE_LENGTH (sregno) >= 0)
{ {
REG_LIVE_LENGTH (sregno) -= length; REG_LIVE_LENGTH (sregno) -= length;
/* reg_live_length is only an approximation after /* REG_LIVE_LENGTH is only an approximation after
combine if sched is not run, so make sure that we combine if sched is not run, so make sure that we
still have a reasonable value. */ still have a reasonable value. */
if (REG_LIVE_LENGTH (sregno) < 2) if (REG_LIVE_LENGTH (sregno) < 2)
...@@ -907,7 +909,7 @@ optimize_reg_copy_1 (insn, dest, src) ...@@ -907,7 +909,7 @@ optimize_reg_copy_1 (insn, dest, src)
REG_NOTES (p) = dest_death; REG_NOTES (p) = dest_death;
} }
return; return ! failed;
} }
/* If SRC is a hard register which is set or killed in some other /* If SRC is a hard register which is set or killed in some other
...@@ -916,6 +918,7 @@ optimize_reg_copy_1 (insn, dest, src) ...@@ -916,6 +918,7 @@ optimize_reg_copy_1 (insn, dest, src)
&& dead_or_set_p (p, src)) && dead_or_set_p (p, src))
break; break;
} }
return 0;
} }
/* INSN is a copy of SRC to DEST, in which SRC dies. See if we now have /* INSN is a copy of SRC to DEST, in which SRC dies. See if we now have
...@@ -932,7 +935,7 @@ optimize_reg_copy_1 (insn, dest, src) ...@@ -932,7 +935,7 @@ optimize_reg_copy_1 (insn, dest, src)
It is assumed that DEST and SRC are pseudos; it is too complicated to do It is assumed that DEST and SRC are pseudos; it is too complicated to do
this for hard registers since the substitutions we may make might fail. */ this for hard registers since the substitutions we may make might fail. */
static void void
optimize_reg_copy_2 (insn, dest, src) optimize_reg_copy_2 (insn, dest, src)
rtx insn; rtx insn;
rtx dest; rtx dest;
......
gcc/regmove.c
/* Move registers around to reduce number of move instructions needed. /* Move registers around to reduce number of move instructions needed.
Copyright (C) 1987, 88, 89, 92-5, 1996, 1997 Free Software Foundation, Inc. Copyright (C) 1987, 88, 89, 92-97, 1998 Free Software Foundation, Inc.
This file is part of GNU CC. This file is part of GNU CC.
...@@ -39,11 +39,38 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ ...@@ -39,11 +39,38 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "output.h" #include "output.h"
#include "reload.h" #include "reload.h"
#include "regs.h" #include "regs.h"
#include "hard-reg-set.h"
#include "flags.h"
#include "expr.h"
#include "insn-flags.h"
#ifndef REG_N_CALLS_CROSSED
#define REG_N_CALLS_CROSSED(x) (reg_n_calls_crossed[(x)])
#define REG_N_SETS(x) (reg_n_sets[(x)])
#define REG_N_REFS(x) (reg_n_refs[(x)])
#define REG_N_DEATHS(x) (reg_n_deaths[(x)])
#define REG_LIVE_LENGTH(x) (reg_live_length[(x)])
#endif
static void optimize_reg_copy_3 PROTO((rtx, rtx, rtx));
extern int flag_regmove;
struct match {
int with[MAX_RECOG_OPERANDS];
enum { READ, WRITE, READWRITE } use[MAX_RECOG_OPERANDS];
int commutative[MAX_RECOG_OPERANDS];
int early_clobber[MAX_RECOG_OPERANDS];
};
static int find_matches PROTO((rtx, struct match *));
static int fixup_match_1 PROTO((rtx, rtx, rtx, rtx, rtx, int, int, int, FILE *))
;
static int reg_is_remote_constant_p PROTO((rtx, rtx, rtx));
static int stable_but_for_p PROTO((rtx, rtx, rtx)); static int stable_but_for_p PROTO((rtx, rtx, rtx));
static int loop_depth;
#if defined (HAVE_POST_INCREMENT) || defined (HAVE_POST_DECREMENT) \ #ifdef AUTO_INC_DEC
|| defined (HAVE_PRE_INCREMENT) || defined (HAVE_PRE_DECREMENT)
/* INC_INSN is an instruction that adds INCREMENT to REG. /* INC_INSN is an instruction that adds INCREMENT to REG.
Try to fold INC_INSN as a post/pre in/decrement into INSN. Try to fold INC_INSN as a post/pre in/decrement into INSN.
...@@ -108,111 +135,368 @@ try_auto_increment (insn, inc_insn, inc_insn_set, reg, increment, pre) ...@@ -108,111 +135,368 @@ try_auto_increment (insn, inc_insn, inc_insn_set, reg, increment, pre)
} }
return 0; return 0;
} }
#endif /* defined (HAVE_POST_INCREMENT) || defined (HAVE_POST_DECREMENT) */ #endif /* AUTO_INC_DEC */
static int *regno_src_regno;
/* Indicate how good a choice REG (which appears as a source) is to replace
a destination register with. The higher the returned value, the better
the choice. The main objective is to avoid using a register that is
a candidate for tying to a hard register, since the output might in
turn be a candidate to be tied to a different hard register. */
int
replacement_quality(reg)
rtx reg;
{
int src_regno;
void /* Bad if this isn't a register at all. */
regmove_optimize (f, nregs, regmove_dump_file) if (GET_CODE (reg) != REG)
rtx f; return 0;
int nregs;
FILE *regmove_dump_file; /* If this register is not meant to get a hard register,
it is a poor choice. */
if (REG_LIVE_LENGTH (REGNO (reg)) < 0)
return 0;
src_regno = regno_src_regno[REGNO (reg)];
/* If it was not copied from another register, it is fine. */
if (src_regno < 0)
return 3;
/* Copied from a hard register? */
if (src_regno < FIRST_PSEUDO_REGISTER)
return 1;
/* Copied from a pseudo register - not as bad as from a hard register,
yet still cumbersome, since the register live length will be lengthened
when the registers get tied. */
return 2;
}
/* INSN is a ZERO_EXTEND or SIGN_EXTEND of SRC to DEST.
Look if SRC dies there, and if it is only set once, by loading
it from memory. If so, try to encorporate the zero/sign extension
into the memory read, change SRC to the mode of DEST, and alter
the remaining accesses to use the appropriate SUBREG. This allows
SRC and DEST to be tied later. */
static void
optimize_reg_copy_3 (insn, dest, src)
rtx insn;
rtx dest;
rtx src;
{ {
#ifdef REGISTER_CONSTRAINTS rtx src_reg = XEXP (src, 0);
int src_no = REGNO (src_reg);
int dst_no = REGNO (dest);
rtx p, set, subreg;
enum machine_mode old_mode;
if (src_no < FIRST_PSEUDO_REGISTER
|| dst_no < FIRST_PSEUDO_REGISTER
|| ! find_reg_note (insn, REG_DEAD, src_reg)
|| REG_N_SETS (src_no) != 1)
return;
for (p = PREV_INSN (insn); ! reg_set_p (src_reg, p); p = PREV_INSN (p))
{
if (GET_RTX_CLASS (GET_CODE (p)) != 'i')
continue;
if (GET_CODE (p) == JUMP_INSN)
return;
}
if (! (set = single_set (p))
|| GET_CODE (SET_SRC (set)) != MEM
|| SET_DEST (set) != src_reg)
return;
old_mode = GET_MODE (src_reg);
PUT_MODE (src_reg, GET_MODE (src));
XEXP (src, 0) = SET_SRC (set);
if (! validate_change (p, &SET_SRC (set), src, 0))
{
PUT_MODE (src_reg, old_mode);
XEXP (src, 0) = src_reg;
return;
}
subreg = gen_rtx(SUBREG, old_mode, src_reg, 0);
while (p = NEXT_INSN (p), p != insn)
{
if (GET_RTX_CLASS (GET_CODE (p)) != 'i')
continue;
validate_replace_rtx (src_reg, subreg, p);
}
validate_replace_rtx (src, src_reg, insn);
}
/* Return whether REG is set in only one location, and is set to a
constant, but is set in a different basic block from INSN (an
instructions which uses REG). In this case REG is equivalent to a
constant, and we don't want to break that equivalence, because that
may increase register pressure and make reload harder. If REG is
set in the same basic block as INSN, we don't worry about it,
because we'll probably need a register anyhow (??? but what if REG
is used in a different basic block as well as this one?). FIRST is
the first insn in the function. */
static int
reg_is_remote_constant_p (reg, insn, first)
rtx reg;
rtx insn; rtx insn;
int matches[MAX_RECOG_OPERANDS][MAX_RECOG_OPERANDS]; rtx first;
int modified[MAX_RECOG_OPERANDS]; {
int early_clobber[MAX_RECOG_OPERANDS]; register rtx p;
int commutative;
int pass;
/* A forward/backward pass. Replace output operands with input operands. */ if (REG_N_SETS (REGNO (reg)) != 1)
return 0;
for (pass = 0; pass < 2; pass++) /* Look for the set. */
for (p = LOG_LINKS (insn); p; p = XEXP (p, 1))
{ {
if (regmove_dump_file) rtx s;
fprintf (regmove_dump_file, "Starting %s pass...\n",
pass ? "backward" : "forward");
for (insn = pass ? get_last_insn () : f; insn; if (REG_NOTE_KIND (p) != 0)
insn = pass ? PREV_INSN (insn) : NEXT_INSN (insn)) continue;
s = single_set (XEXP (p, 0));
if (s != 0
&& GET_CODE (SET_DEST (s)) == REG
&& REGNO (SET_DEST (s)) == REGNO (reg))
{ {
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i') /* The register is set in the same basic block. */
return 0;
}
}
for (p = first; p && p != insn; p = NEXT_INSN (p))
{ {
int insn_code_number = recog_memoized (insn); rtx s;
int operand_number, match_number;
if (insn_code_number < 0) if (GET_RTX_CLASS (GET_CODE (p)) != 'i')
continue; continue;
s = single_set (p);
if (s != 0
&& GET_CODE (SET_DEST (s)) == REG
&& REGNO (SET_DEST (s)) == REGNO (reg))
{
/* This is the instruction which sets REG. If there is a
REG_EQUAL note, then REG is equivalent to a constant. */
if (find_reg_note (p, REG_EQUAL, NULL_RTX))
return 1;
return 0;
}
}
insn_extract (insn); return 0;
if (! constrain_operands (insn_code_number, 0)) }
continue;
commutative = -1; /* cse disrupts preincrement / postdecrement squences when it finds a
hard register as ultimate source, like the frame pointer. */
int fixup_match_2 (insn, dst, src, offset, regmove_dump_file)
rtx insn, dst, src, offset;
FILE *regmove_dump_file;
{
rtx p, dst_death = 0;
int length, num_calls = 0;
/* Must initialize this before the loop, because the code for /* If SRC dies in INSN, we'd have to move the death note. This is
the commutative case may set matches for operands other than considered to be very unlikely, so we just skip the optimization
the current one. */ in this case. */
bzero ((char *)matches, sizeof (matches)); if (find_regno_note (insn, REG_DEAD, REGNO (src)))
return 0;
for (operand_number = 0; /* Scan backward to find the first instruction that sets DST. */
operand_number < insn_n_operands[insn_code_number];
operand_number++) for (length = 0, p = PREV_INSN (insn); p; p = PREV_INSN (p))
{ {
int output_operand = 0; rtx pset;
int matching_operand = operand_number;
char *p, c; if (GET_CODE (p) == CODE_LABEL
int i = 0; || GET_CODE (p) == JUMP_INSN
|| (GET_CODE (p) == NOTE
&& (NOTE_LINE_NUMBER (p) == NOTE_INSN_LOOP_BEG
|| NOTE_LINE_NUMBER (p) == NOTE_INSN_LOOP_END)))
break;
modified[operand_number] = 0; if (GET_RTX_CLASS (GET_CODE (p)) != 'i')
early_clobber[operand_number] = 0; continue;
p = insn_operand_constraint[insn_code_number][operand_number]; if (find_regno_note (p, REG_DEAD, REGNO (dst)))
dst_death = p;
if (! dst_death)
length++;
if (*p == '=') pset = single_set (p);
modified[operand_number] = 2; if (pset && SET_DEST (pset) == dst
else if (*p == '+') && GET_CODE (SET_SRC (pset)) == PLUS
modified[operand_number] = 1; && XEXP (SET_SRC (pset), 0) == src
&& GET_CODE (XEXP (SET_SRC (pset), 1)) == CONST_INT)
{
HOST_WIDE_INT newconst
= INTVAL (offset) - INTVAL (XEXP (SET_SRC (pset), 1));
if (validate_change (insn, &PATTERN (insn),
gen_addsi3 (dst, dst, GEN_INT (newconst)), 0))
{
/* Remove the death note for DST from DST_DEATH. */
if (dst_death)
{
remove_death (REGNO (dst), dst_death);
REG_LIVE_LENGTH (REGNO (dst)) += length;
REG_N_CALLS_CROSSED (REGNO (dst)) += num_calls;
}
for (;*p && i < which_alternative; p++) REG_N_REFS (REGNO (dst)) += loop_depth;
if (*p == ',') REG_N_REFS (REGNO (src)) -= loop_depth;
i++;
while ((c = *p++) != '\0' && c != ',') if (regmove_dump_file)
switch (c) fprintf (regmove_dump_file,
"Fixed operand of insn %d.\n",
INSN_UID (insn));
#ifdef AUTO_INC_DEC
for (p = PREV_INSN (insn); p; p = PREV_INSN (p))
{ {
case '=': if (GET_CODE (p) == CODE_LABEL
break; || GET_CODE (p) == JUMP_INSN
case '+': || (GET_CODE (p) == NOTE
&& (NOTE_LINE_NUMBER (p) == NOTE_INSN_LOOP_BEG
|| NOTE_LINE_NUMBER (p) == NOTE_INSN_LOOP_END)))
break; break;
case '&': if (reg_overlap_mentioned_p (dst, PATTERN (p)))
early_clobber[operand_number] = 1; {
if (try_auto_increment (p, insn, 0, dst, newconst, 0))
return 1;
break; break;
case '%': }
commutative = operand_number; }
for (p = NEXT_INSN (insn); p; p = NEXT_INSN (p))
{
if (GET_CODE (p) == CODE_LABEL
|| GET_CODE (p) == JUMP_INSN
|| (GET_CODE (p) == NOTE
&& (NOTE_LINE_NUMBER (p) == NOTE_INSN_LOOP_BEG
|| NOTE_LINE_NUMBER (p) == NOTE_INSN_LOOP_END)))
break; break;
case '0': case '1': case '2': case '3': case '4': if (reg_overlap_mentioned_p (dst, PATTERN (p)))
case '5': case '6': case '7': case '8': case '9':
c -= '0';
matches[operand_number][c] = 1;
if (commutative >= 0)
{ {
if (c == commutative || c == commutative + 1) try_auto_increment (p, insn, 0, dst, newconst, 1);
break;
}
}
#endif
return 1;
}
}
if (reg_set_p (dst, PATTERN (p)))
break;
/* If we have passed a call instruction, and the
pseudo-reg SRC is not already live across a call,
then don't perform the optimization. */
/* reg_set_p is overly conservative for CALL_INSNS, thinks that all
hard regs are clobbered. Thus, we only use it for src for
non-call insns. */
if (GET_CODE (p) == CALL_INSN)
{ {
int other = c + (c == commutative ? 1 : -1); if (! dst_death)
matches[operand_number][other] = 1; num_calls++;
if (REG_N_CALLS_CROSSED (REGNO (src)) == 0)
break;
if (call_used_regs [REGNO (dst)]
|| find_reg_fusage (p, CLOBBER, dst))
break;
}
else if (reg_set_p (src, PATTERN (p)))
break;
} }
if (operand_number == commutative
|| operand_number == commutative + 1) return 0;
}
void
regmove_optimize (f, nregs, regmove_dump_file)
rtx f;
int nregs;
FILE *regmove_dump_file;
{
rtx insn;
struct match match;
int pass;
int maxregnum = max_reg_num (), i;
regno_src_regno = (int *)alloca (sizeof *regno_src_regno * maxregnum);
for (i = maxregnum; --i >= 0; ) regno_src_regno[i] = -1;
/* A forward/backward pass. Replace output operands with input operands. */
loop_depth = 1;
for (pass = 0; pass <= 2; pass++)
{ {
int other = (operand_number if (! flag_regmove && pass >= flag_expensive_optimizations)
+ (operand_number == commutative return;
? 1 : -1));
matches[other][c] = 1; if (regmove_dump_file)
fprintf (regmove_dump_file, "Starting %s pass...\n",
pass ? "backward" : "forward");
for (insn = pass ? get_last_insn () : f; insn;
insn = pass ? PREV_INSN (insn) : NEXT_INSN (insn))
{
rtx set;
int insn_code_number;
int operand_number, match_number;
if (GET_CODE (insn) == NOTE)
{
if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG)
loop_depth++;
else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END)
loop_depth--;
} }
set = single_set (insn);
if (! set)
continue;
if (flag_expensive_optimizations && ! pass
&& (GET_CODE (SET_SRC (set)) == SIGN_EXTEND
|| GET_CODE (SET_SRC (set)) == ZERO_EXTEND)
&& GET_CODE (XEXP (SET_SRC (set), 0)) == REG
&& GET_CODE (SET_DEST(set)) == REG)
optimize_reg_copy_3 (insn, SET_DEST (set), SET_SRC (set));
if (flag_expensive_optimizations && ! pass
&& GET_CODE (SET_SRC (set)) == REG
&& GET_CODE (SET_DEST(set)) == REG)
{
/* If this is a register-register copy where SRC is not dead,
see if we can optimize it. If this optimization succeeds,
it will become a copy where SRC is dead. */
if ((find_reg_note (insn, REG_DEAD, SET_SRC (set))
|| optimize_reg_copy_1 (insn, SET_DEST (set), SET_SRC (set)))
&& REGNO (SET_DEST (set)) >= FIRST_PSEUDO_REGISTER)
{
/* Similarly for a pseudo-pseudo copy when SRC is dead. */
if (REGNO (SET_SRC (set)) >= FIRST_PSEUDO_REGISTER)
optimize_reg_copy_2 (insn, SET_DEST (set), SET_SRC (set));
if (regno_src_regno[REGNO (SET_DEST (set))] < 0
&& SET_SRC (set) != SET_DEST (set))
{
int srcregno = REGNO (SET_SRC(set));
if (regno_src_regno[srcregno] >= 0)
srcregno = regno_src_regno[srcregno];
regno_src_regno[REGNO (SET_DEST (set))] = srcregno;
} }
break;
} }
} }
#ifdef REGISTER_CONSTRAINTS
insn_code_number
= find_matches (insn, &match);
if (insn_code_number < 0)
continue;
/* Now scan through the operands looking for a source operand /* Now scan through the operands looking for a source operand
which is supposed to match the destination operand. which is supposed to match the destination operand.
...@@ -225,29 +509,19 @@ regmove_optimize (f, nregs, regmove_dump_file) ...@@ -225,29 +509,19 @@ regmove_optimize (f, nregs, regmove_dump_file)
operand_number < insn_n_operands[insn_code_number]; operand_number < insn_n_operands[insn_code_number];
operand_number++) operand_number++)
{ {
for (match_number = 0; rtx p, src, dst, src_subreg;
match_number < insn_n_operands[insn_code_number]; enum reg_class src_class, dst_class;
match_number++)
{ match_number = match.with[operand_number];
rtx set, p, src, dst, src_subreg;
rtx post_inc = 0, post_inc_set = 0, search_end = 0;
rtx src_note, dst_note;
int success = 0;
int num_calls = 0;
enum rtx_code code = NOTE;
HOST_WIDE_INT insn_const, newconst;
rtx overlap = 0; /* need to move insn ? */
/* Nothing to do if the two operands aren't supposed to /* Nothing to do if the two operands aren't supposed to match. */
match. */ if (match_number < 0)
if (matches[operand_number][match_number] == 0)
continue; continue;
src = recog_operand[operand_number]; src = recog_operand[operand_number];
dst = recog_operand[match_number]; dst = recog_operand[match_number];
if (GET_CODE (src) != REG if (GET_CODE (src) != REG)
|| REGNO (src) < FIRST_PSEUDO_REGISTER)
continue; continue;
src_subreg = src; src_subreg = src;
...@@ -264,31 +538,414 @@ regmove_optimize (f, nregs, regmove_dump_file) ...@@ -264,31 +538,414 @@ regmove_optimize (f, nregs, regmove_dump_file)
|| REGNO (dst) < FIRST_PSEUDO_REGISTER) || REGNO (dst) < FIRST_PSEUDO_REGISTER)
continue; continue;
/* If the operands already match, then there is nothing if (REGNO (src) < FIRST_PSEUDO_REGISTER)
to do. */ {
if (operands_match_p (src, dst)) if (match.commutative[operand_number] < operand_number)
regno_src_regno[REGNO (dst)] = REGNO (src);
continue; continue;
}
set = single_set (insn); if (REG_LIVE_LENGTH (REGNO (src)) < 0)
if (! set)
continue; continue;
/* operand_number/src must be a read-only operand, and /* operand_number/src must be a read-only operand, and
match_operand/dst must be a write-only operand. */ match_operand/dst must be a write-only operand. */
if (modified[match_number] != 2) if (match.use[operand_number] != READ
|| match.use[match_number] != WRITE)
continue; continue;
if (early_clobber[match_number] == 1) if (match.early_clobber[match_number]
&& count_occurrences (PATTERN (insn), src) > 1)
continue; continue;
if (modified[operand_number] != 0) /* Make sure match_operand is the destination. */
if (recog_operand[match_number] != SET_DEST (set))
continue; continue;
/* Make sure match_operand is the destination. */ /* If the operands already match, then there is nothing to do. */
/* But in the commutative case, we might find a better match. */
if (operands_match_p (src, dst)
|| (match.commutative[operand_number] >= 0
&& operands_match_p (recog_operand[match.commutative
[operand_number]], dst)
&& (replacement_quality (recog_operand[match.commutative
[operand_number]])
>= replacement_quality (src))))
continue;
src_class = reg_preferred_class (REGNO (src));
dst_class = reg_preferred_class (REGNO (dst));
if (src_class != dst_class
&& (! reg_class_subset_p (src_class, dst_class)
|| CLASS_LIKELY_SPILLED_P (src_class))
&& (! reg_class_subset_p (dst_class, src_class)
|| CLASS_LIKELY_SPILLED_P (dst_class)))
continue;
if (fixup_match_1 (insn, set, src, src_subreg, dst, pass,
operand_number, match_number,
regmove_dump_file))
break;
}
}
}
/* A backward pass. Replace input operands with output operands. */
if (regmove_dump_file)
fprintf (regmove_dump_file, "Starting backward pass...\n");
loop_depth = 1;
for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
{
if (GET_CODE (insn) == NOTE)
{
if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END)
loop_depth++;
else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG)
loop_depth--;
}
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
{
int insn_code_number = find_matches (insn, &match);
int operand_number, match_number;
if (insn_code_number < 0)
continue;
/* Now scan through the operands looking for a destination operand
which is supposed to match a source operand.
Then scan backward for an instruction which sets the source
operand. If safe, then replace the source operand with the
dest operand in both instructions. */
for (operand_number = 0;
operand_number < insn_n_operands[insn_code_number];
operand_number++)
{
rtx set, p, src, dst;
rtx src_note, dst_note;
int success = 0;
int num_calls = 0;
enum reg_class src_class, dst_class;
int length;
match_number = match.with[operand_number];
/* Nothing to do if the two operands aren't supposed to match. */
if (match_number < 0)
continue;
dst = recog_operand[match_number];
src = recog_operand[operand_number];
if (GET_CODE (src) != REG)
continue;
if (GET_CODE (dst) != REG
|| REGNO (dst) < FIRST_PSEUDO_REGISTER
|| REG_LIVE_LENGTH (REGNO (dst)) < 0)
continue;
/* If the operands already match, then there is nothing to do. */
if (operands_match_p (src, dst)
|| (match.commutative[operand_number] >= 0
&& operands_match_p (recog_operand[match.commutative[operand_number]], dst)))
continue;
set = single_set (insn);
if (! set)
continue;
/* match_number/dst must be a write-only operand, and
operand_operand/src must be a read-only operand. */
if (match.use[operand_number] != READ
|| match.use[match_number] != WRITE)
continue;
if (match.early_clobber[match_number]
&& count_occurrences (PATTERN (insn), src) > 1)
continue;
/* Make sure match_number is the destination. */
if (recog_operand[match_number] != SET_DEST (set)) if (recog_operand[match_number] != SET_DEST (set))
continue; continue;
src_note = find_reg_note (insn, REG_DEAD, src); if (REGNO (src) < FIRST_PSEUDO_REGISTER)
{
if (GET_CODE (SET_SRC (set)) == PLUS
&& GET_CODE (XEXP (SET_SRC (set), 1)) == CONST_INT
&& XEXP (SET_SRC (set), 0) == src
&& fixup_match_2 (insn, dst, src,
XEXP (SET_SRC (set), 1),
regmove_dump_file))
break;
continue;
}
src_class = reg_preferred_class (REGNO (src));
dst_class = reg_preferred_class (REGNO (dst));
if (src_class != dst_class
&& (! reg_class_subset_p (src_class, dst_class)
|| CLASS_LIKELY_SPILLED_P (src_class))
&& (! reg_class_subset_p (dst_class, src_class)
|| CLASS_LIKELY_SPILLED_P (dst_class)))
continue;
if (! (src_note = find_reg_note (insn, REG_DEAD, src)))
continue;
/* Can not modify an earlier insn to set dst if this insn
uses an old value in the source. */
if (reg_overlap_mentioned_p (dst, SET_SRC (set)))
continue;
if (regmove_dump_file)
fprintf (regmove_dump_file,
"Could fix operand %d of insn %d matching operand %d.\n",
operand_number, INSN_UID (insn), match_number);
/* If src is set once in a different basic block,
and is set equal to a constant, then do not use
it for this optimization, as this would make it
no longer equivalent to a constant. */
if (reg_is_remote_constant_p (src, insn, f))
continue;
/* Scan backward to find the first instruction that uses
the input operand. If the operand is set here, then
replace it in both instructions with match_number. */
for (length = 0, p = PREV_INSN (insn); p; p = PREV_INSN (p))
{
rtx pset;
if (GET_CODE (p) == CODE_LABEL
|| GET_CODE (p) == JUMP_INSN
|| (GET_CODE (p) == NOTE
&& (NOTE_LINE_NUMBER (p) == NOTE_INSN_LOOP_BEG
|| NOTE_LINE_NUMBER (p) == NOTE_INSN_LOOP_END)))
break;
if (GET_RTX_CLASS (GET_CODE (p)) != 'i')
continue;
length++;
/* ??? See if all of SRC is set in P. This test is much
more conservative than it needs to be. */
pset = single_set (p);
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. */
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_operand_loc[match_number],
dst, 0);
}
}
break;
}
if (reg_overlap_mentioned_p (src, PATTERN (p))
|| reg_overlap_mentioned_p (dst, PATTERN (p)))
break;
/* If we have passed a call instruction, and the
pseudo-reg DST is not already live across a call,
then don't perform the optimization. */
if (GET_CODE (p) == CALL_INSN)
{
num_calls++;
if (REG_N_CALLS_CROSSED (REGNO (dst)) == 0)
break;
}
}
if (success)
{
int dstno, srcno;
/* Remove the death note for SRC from INSN. */
remove_note (insn, src_note);
/* Move the death note for SRC to P if it is used
there. */
if (reg_overlap_mentioned_p (src, PATTERN (p)))
{
XEXP (src_note, 1) = REG_NOTES (p);
REG_NOTES (p) = src_note;
}
/* If there is a REG_DEAD note for DST on P, then remove
it, because DST is now set there. */
if (dst_note = find_reg_note (p, REG_DEAD, dst))
remove_note (p, dst_note);
dstno = REGNO (dst);
srcno = REGNO (src);
REG_N_SETS (dstno)++;
REG_N_SETS (srcno)--;
REG_N_CALLS_CROSSED (dstno) += num_calls;
REG_N_CALLS_CROSSED (srcno) -= num_calls;
REG_LIVE_LENGTH (dstno) += length;
if (REG_LIVE_LENGTH (srcno) >= 0)
{
REG_LIVE_LENGTH (srcno) -= length;
/* REG_LIVE_LENGTH is only an approximation after
combine if sched is not run, so make sure that we
still have a reasonable value. */
if (REG_LIVE_LENGTH (srcno) < 2)
REG_LIVE_LENGTH (srcno) = 2;
}
/* We assume that a register is used exactly once per
insn in the updates above. If this is not correct,
no great harm is done. */
REG_N_REFS (dstno) += 2 * loop_depth;
REG_N_REFS (srcno) -= 2 * loop_depth;
/* If that was the only time src was set,
and src was not live at the start of the
function, we know that we have no more
references to src; clear REG_N_REFS so it
won't make reload do any work. */
if (REG_N_SETS (REGNO (src)) == 0
&& ! regno_uninitialized (REGNO (src)))
REG_N_REFS (REGNO (src)) = 0;
if (regmove_dump_file)
fprintf (regmove_dump_file,
"Fixed operand %d of insn %d matching operand %d.\n",
operand_number, INSN_UID (insn), match_number);
break;
}
}
}
}
#endif /* REGISTER_CONSTRAINTS */
}
static int
find_matches (insn, matchp)
rtx insn;
struct match *matchp;
{
int likely_spilled[MAX_RECOG_OPERANDS];
int operand_number;
int insn_code_number = recog_memoized (insn);
int any_matches = 0;
if (insn_code_number < 0)
return -1;
insn_extract (insn);
if (! constrain_operands (insn_code_number, 0))
return -1;
/* Must initialize this before main loop, because the code for
the commutative case may set matches for operands other than
the current one. */
for (operand_number = insn_n_operands[insn_code_number];
--operand_number >= 0; )
matchp->with[operand_number] = matchp->commutative[operand_number] = -1;
for (operand_number = 0; operand_number < insn_n_operands[insn_code_number];
operand_number++)
{
int output_operand = 0;
int matching_operand = operand_number;
char *p, c;
int i = 0;
p = insn_operand_constraint[insn_code_number][operand_number];
likely_spilled[operand_number] = 0;
matchp->use[operand_number] = READ;
if (*p == '=')
matchp->use[operand_number] = WRITE;
else if (*p == '+')
matchp->use[operand_number] = READWRITE;
for (;*p && i < which_alternative; p++)
if (*p == ',')
i++;
while ((c = *p++) != '\0' && c != ',')
switch (c)
{
case '=':
break;
case '+':
break;
case '&':
matchp->early_clobber[operand_number] = 1;
break;
case '%':
matchp->commutative[operand_number] = operand_number + 1;
matchp->commutative[operand_number + 1] = operand_number;
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
c -= '0';
if (c < operand_number && likely_spilled[c])
break;
matchp->with[operand_number] = c;
any_matches = 1;
if (matchp->commutative[operand_number] >= 0)
matchp->with[matchp->commutative[operand_number]] = c;
break;
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'h':
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_LETTER (c)))
likely_spilled[operand_number] = 1;
break;
}
}
return any_matches ? insn_code_number : -1;
}
/* Try to replace output operand DST in SET, with input operand SRC. SET is
the only set in INSN. INSN has just been recgnized and constrained.
SRC is operand number OPERAND_NUMBER in INSN.
DST is operand number MATCH_NUMBER in INSN.
If BACKWARD is nonzero, we have been called in a backward pass.
Return nonzero for success. */
static int
fixup_match_1 (insn, set, src, src_subreg, dst, backward, operand_number,
match_number, regmove_dump_file)
rtx insn, set, src, src_subreg, dst;
int backward, operand_number, match_number;
FILE *regmove_dump_file;
{
rtx p;
rtx post_inc = 0, post_inc_set = 0, search_end = 0;
int success = 0;
int num_calls = 0, s_num_calls = 0;
enum rtx_code code = NOTE;
HOST_WIDE_INT insn_const, newconst;
rtx overlap = 0; /* need to move insn ? */
rtx src_note = find_reg_note (insn, REG_DEAD, src), dst_note;
int length, s_length, true_loop_depth;
if (! src_note) if (! src_note)
{ {
...@@ -304,11 +961,10 @@ regmove_optimize (f, nregs, regmove_dump_file) ...@@ -304,11 +961,10 @@ regmove_optimize (f, nregs, regmove_dump_file)
if ((code == PLUS || code == LSHIFTRT if ((code == PLUS || code == LSHIFTRT
|| code == ASHIFT || code == ASHIFTRT) || code == ASHIFT || code == ASHIFTRT)
&& XEXP (SET_SRC (set), 0) == src && XEXP (SET_SRC (set), 0) == src
&& (GET_CODE (XEXP (SET_SRC (set), 1)) && GET_CODE (XEXP (SET_SRC (set), 1)) == CONST_INT)
== CONST_INT))
insn_const = INTVAL (XEXP (SET_SRC (set), 1)); insn_const = INTVAL (XEXP (SET_SRC (set), 1));
else if (! stable_but_for_p (SET_SRC (set), src, dst)) else if (! stable_but_for_p (SET_SRC (set), src, dst))
continue; return 0;
else else
/* We might find a src_note while scanning. */ /* We might find a src_note while scanning. */
code = NOTE; code = NOTE;
...@@ -319,96 +975,85 @@ regmove_optimize (f, nregs, regmove_dump_file) ...@@ -319,96 +975,85 @@ regmove_optimize (f, nregs, regmove_dump_file)
"Could fix operand %d of insn %d matching operand %d.\n", "Could fix operand %d of insn %d matching operand %d.\n",
operand_number, INSN_UID (insn), match_number); operand_number, INSN_UID (insn), match_number);
/* ??? If src is set once, and is set equal to a /* If SRC is equivalent to a constant set in a different basic block,
constant, then do not use it for this optimization, then do not use it for this optimization. We want the equivalence
as this would make it no longer equivalent to a so that if we have to reload this register, we can reload the
constant? */ constant, rather than extending the lifespan of the register. */
if (reg_is_remote_constant_p (src, insn, get_insns ()))
return 0;
/* Scan forward to find the next instruction that /* Scan forward to find the next instruction that
uses the output operand. If the operand dies here, uses the output operand. If the operand dies here,
then replace it in both instructions with then replace it in both instructions with
operand_number. */ operand_number. */
for (p = NEXT_INSN (insn); p; p = NEXT_INSN (p)) for (length = s_length = 0, p = NEXT_INSN (insn); p; p = NEXT_INSN (p))
{ {
if (GET_CODE (p) == CODE_LABEL if (GET_CODE (p) == CODE_LABEL || GET_CODE (p) == JUMP_INSN
|| GET_CODE (p) == JUMP_INSN
|| (GET_CODE (p) == NOTE || (GET_CODE (p) == NOTE
&& ((NOTE_LINE_NUMBER (p) && (NOTE_LINE_NUMBER (p) == NOTE_INSN_LOOP_BEG
== NOTE_INSN_LOOP_BEG) || NOTE_LINE_NUMBER (p) == NOTE_INSN_LOOP_END)))
|| (NOTE_LINE_NUMBER (p)
== NOTE_INSN_LOOP_END))))
break; break;
if (GET_RTX_CLASS (GET_CODE (p)) != 'i') if (GET_RTX_CLASS (GET_CODE (p)) != 'i')
continue; continue;
length++;
if (src_note)
s_length++;
if (reg_set_p (src, p) || reg_set_p (dst, p) if (reg_set_p (src, p) || reg_set_p (dst, p)
|| (GET_CODE (PATTERN (p)) == USE || (GET_CODE (PATTERN (p)) == USE
&& reg_overlap_mentioned_p (src, && reg_overlap_mentioned_p (src, XEXP (PATTERN (p), 0))))
XEXP (PATTERN (p),
0))))
break; break;
/* See if all of DST dies in P. This test is /* See if all of DST dies in P. This test is
slightly more conservative than it needs to be. */ slightly more conservative than it needs to be. */
if ((dst_note if ((dst_note = find_regno_note (p, REG_DEAD, REGNO (dst)))
= find_regno_note (p, REG_DEAD, REGNO (dst))) && (GET_MODE (XEXP (dst_note, 0)) == GET_MODE (dst)))
&& (GET_MODE (XEXP (dst_note, 0))
== GET_MODE (dst)))
{ {
if (! src_note) if (! src_note)
{ {
rtx q; rtx q;
rtx set2; rtx set2;
/* If an optimization is done, the value /* If an optimization is done, the value of SRC while P
of SRC while P is executed will be is executed will be changed. Check that this is OK. */
changed. Check that this is OK. */ if (reg_overlap_mentioned_p (src, PATTERN (p)))
if (reg_overlap_mentioned_p (src,
PATTERN (p)))
break; break;
for (q = p; q; q = NEXT_INSN (q)) for (q = p; q; q = NEXT_INSN (q))
{ {
if (GET_CODE (q) == CODE_LABEL if (GET_CODE (q) == CODE_LABEL || GET_CODE (q) == JUMP_INSN
|| GET_CODE (q) == JUMP_INSN
|| (GET_CODE (q) == NOTE || (GET_CODE (q) == NOTE
&& ((NOTE_LINE_NUMBER (q) && (NOTE_LINE_NUMBER (q) == NOTE_INSN_LOOP_BEG
== NOTE_INSN_LOOP_BEG) || NOTE_LINE_NUMBER (q) == NOTE_INSN_LOOP_END)))
|| (NOTE_LINE_NUMBER (q)
== NOTE_INSN_LOOP_END))))
{ {
q = 0; q = 0;
break; break;
} }
if (GET_RTX_CLASS (GET_CODE (q)) != 'i') if (GET_RTX_CLASS (GET_CODE (q)) != 'i')
continue; continue;
if (reg_overlap_mentioned_p (src, if (reg_overlap_mentioned_p (src, PATTERN (q))
PATTERN (q))
|| reg_set_p (src, q)) || reg_set_p (src, q))
break; break;
} }
if (q) if (q)
set2 = single_set (q); set2 = single_set (q);
if (! q || ! set2 if (! q || ! set2 || GET_CODE (SET_SRC (set2)) != code
|| GET_CODE (SET_SRC (set2)) != code
|| XEXP (SET_SRC (set2), 0) != src || XEXP (SET_SRC (set2), 0) != src
|| (GET_CODE (XEXP (SET_SRC (set2), 1)) || GET_CODE (XEXP (SET_SRC (set2), 1)) != CONST_INT
!= CONST_INT)
|| (SET_DEST (set2) != src || (SET_DEST (set2) != src
&& !find_reg_note (q, REG_DEAD, src))) && ! find_reg_note (q, REG_DEAD, src)))
{ {
/* If this is a PLUS, we can still save /* If this is a PLUS, we can still save a register by doing
a register by doing
src += insn_const; src += insn_const;
P; P;
src -= insn_const; . src -= insn_const; .
This also gives opportunities for This also gives opportunities for subsequent
subsequent optimizations in the optimizations in the backward pass, so do it there. */
backward pass, so do it there. */ if (code == PLUS && backward
if (code == PLUS && pass == 1
#ifdef HAVE_cc0 #ifdef HAVE_cc0
/* We man not emit an insn directly /* We may not emit an insn directly
after P if the latter sets CC0. */ after P if the latter sets CC0. */
&& ! sets_cc0_p (PATTERN (p)) && ! sets_cc0_p (PATTERN (p))
#endif #endif
...@@ -426,9 +1071,7 @@ regmove_optimize (f, nregs, regmove_dump_file) ...@@ -426,9 +1071,7 @@ regmove_optimize (f, nregs, regmove_dump_file)
} }
else else
{ {
newconst newconst = INTVAL (XEXP (SET_SRC (set2), 1)) - insn_const;
= (INTVAL (XEXP (SET_SRC (set2), 1))
- insn_const);
/* Reject out of range shifts. */ /* Reject out of range shifts. */
if (code != PLUS if (code != PLUS
&& (newconst < 0 && (newconst < 0
...@@ -442,17 +1085,13 @@ regmove_optimize (f, nregs, regmove_dump_file) ...@@ -442,17 +1085,13 @@ regmove_optimize (f, nregs, regmove_dump_file)
post_inc_set = set2; post_inc_set = set2;
} }
} }
/* We use 1 as last argument to /* We use 1 as last argument to validate_change so that all
validate_change so that all changes changes are accepted or rejected together by apply_change_group
are accepted or rejected together by when it is called by validate_replace_rtx . */
apply_change_group when it is called
by validate_replace_rtx . */
validate_change (q, &XEXP (SET_SRC (set2), 1), validate_change (q, &XEXP (SET_SRC (set2), 1),
GEN_INT (newconst), 1); GEN_INT (newconst), 1);
} }
validate_change (insn, validate_change (insn, recog_operand_loc[match_number], src, 1);
recog_operand_loc[match_number],
src, 1);
if (validate_replace_rtx (dst, src_subreg, p)) if (validate_replace_rtx (dst, src_subreg, p))
success = 1; success = 1;
break; break;
...@@ -460,8 +1099,7 @@ regmove_optimize (f, nregs, regmove_dump_file) ...@@ -460,8 +1099,7 @@ regmove_optimize (f, nregs, regmove_dump_file)
if (reg_overlap_mentioned_p (dst, PATTERN (p))) if (reg_overlap_mentioned_p (dst, PATTERN (p)))
break; break;
if (! src_note if (! src_note && reg_overlap_mentioned_p (src, PATTERN (p)))
&& reg_overlap_mentioned_p (src, PATTERN (p)))
{ {
/* INSN was already checked to be movable when /* INSN was already checked to be movable when
we found no REG_DEAD note for src on it. */ we found no REG_DEAD note for src on it. */
...@@ -469,36 +1107,40 @@ regmove_optimize (f, nregs, regmove_dump_file) ...@@ -469,36 +1107,40 @@ regmove_optimize (f, nregs, regmove_dump_file)
src_note = find_reg_note (p, REG_DEAD, src); src_note = find_reg_note (p, REG_DEAD, src);
} }
/* If we have passed a call instruction, and the /* If we have passed a call instruction, and the pseudo-reg SRC is not
pseudo-reg SRC is not already live across a call, already live across a call, then don't perform the optimization. */
then don't perform the optimization. */
if (GET_CODE (p) == CALL_INSN) if (GET_CODE (p) == CALL_INSN)
{ {
num_calls++;
if (REG_N_CALLS_CROSSED (REGNO (src)) == 0) if (REG_N_CALLS_CROSSED (REGNO (src)) == 0)
break; break;
num_calls++;
if (src_note)
s_num_calls++;
} }
} }
if (success) if (! success)
{ return 0;
true_loop_depth = backward ? 2 - loop_depth : loop_depth;
/* Remove the death note for DST from P. */ /* Remove the death note for DST from P. */
remove_note (p, dst_note); remove_note (p, dst_note);
if (code == MINUS) if (code == MINUS)
{ {
post_inc post_inc = emit_insn_after (copy_rtx (PATTERN (insn)), p);
= emit_insn_after (copy_rtx (PATTERN (insn)),
p);
#if defined (HAVE_PRE_INCREMENT) || defined (HAVE_PRE_DECREMENT) #if defined (HAVE_PRE_INCREMENT) || defined (HAVE_PRE_DECREMENT)
if (search_end if (search_end
&& try_auto_increment (search_end, post_inc, && try_auto_increment (search_end, post_inc, 0, src, newconst, 1))
0, src, newconst, 1))
post_inc = 0; post_inc = 0;
#endif #endif
validate_change (insn, &XEXP (SET_SRC (set), 1), validate_change (insn, &XEXP (SET_SRC (set), 1), GEN_INT (insn_const), 0);
GEN_INT (insn_const), 0);
REG_N_SETS (REGNO (src))++; REG_N_SETS (REGNO (src))++;
REG_N_REFS (REGNO (src)) += true_loop_depth;
REG_LIVE_LENGTH (REGNO (src))++;
} }
if (overlap) if (overlap)
{ {
...@@ -509,22 +1151,19 @@ regmove_optimize (f, nregs, regmove_dump_file) ...@@ -509,22 +1151,19 @@ regmove_optimize (f, nregs, regmove_dump_file)
remove_note (overlap, src_note); remove_note (overlap, src_note);
#if defined (HAVE_POST_INCREMENT) || defined (HAVE_POST_DECREMENT) #if defined (HAVE_POST_INCREMENT) || defined (HAVE_POST_DECREMENT)
if (code == PLUS if (code == PLUS
&& try_auto_increment (overlap, insn, 0, && try_auto_increment (overlap, insn, 0, src, insn_const, 0))
src, insn_const, 0))
insn = overlap; insn = overlap;
else else
#endif #endif
{ {
rtx notes = REG_NOTES (insn); rtx notes = REG_NOTES (insn);
emit_insn_after_with_line_notes emit_insn_after_with_line_notes (pat, PREV_INSN (p), insn);
(pat, PREV_INSN (p), insn);
PUT_CODE (insn, NOTE); PUT_CODE (insn, NOTE);
NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED; NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
NOTE_SOURCE_FILE (insn) = 0; NOTE_SOURCE_FILE (insn) = 0;
/* emit_insn_after_with_line_notes /* emit_insn_after_with_line_notes has no
has no return value, so search return value, so search for the new insn. */
for the new insn. */
for (insn = p; PATTERN (insn) != pat; ) for (insn = p; PATTERN (insn) != pat; )
insn = PREV_INSN (insn); insn = PREV_INSN (insn);
...@@ -537,15 +1176,13 @@ regmove_optimize (f, nregs, regmove_dump_file) ...@@ -537,15 +1176,13 @@ regmove_optimize (f, nregs, regmove_dump_file)
if (! overlap && (code == PLUS || code == MINUS)) if (! overlap && (code == PLUS || code == MINUS))
{ {
rtx note rtx note = find_reg_note (insn, REG_EQUAL, NULL_RTX);
= find_reg_note (insn, REG_EQUAL, NULL_RTX);
rtx q, set2; rtx q, set2;
int num_calls2 = 0; int num_calls2 = 0, s_length2 = 0;
if (note && CONSTANT_P (XEXP (note, 0))) if (note && CONSTANT_P (XEXP (note, 0)))
{ {
for (q = PREV_INSN (insn); q; for (q = PREV_INSN (insn); q; q = PREV_INSN(q))
q = PREV_INSN(q))
{ {
if (GET_CODE (q) == JUMP_INSN) if (GET_CODE (q) == JUMP_INSN)
{ {
...@@ -554,13 +1191,13 @@ regmove_optimize (f, nregs, regmove_dump_file) ...@@ -554,13 +1191,13 @@ regmove_optimize (f, nregs, regmove_dump_file)
} }
if (GET_RTX_CLASS (GET_CODE (q)) != 'i') if (GET_RTX_CLASS (GET_CODE (q)) != 'i')
continue; continue;
s_length2++;
if (reg_set_p (src, q)) if (reg_set_p (src, q))
{ {
set2 = single_set (q); set2 = single_set (q);
break; break;
} }
if (reg_overlap_mentioned_p (src, if (reg_overlap_mentioned_p (src, PATTERN (q)))
PATTERN (q)))
{ {
q = 0; q = 0;
break; break;
...@@ -568,34 +1205,29 @@ regmove_optimize (f, nregs, regmove_dump_file) ...@@ -568,34 +1205,29 @@ regmove_optimize (f, nregs, regmove_dump_file)
if (GET_CODE (p) == CALL_INSN) if (GET_CODE (p) == CALL_INSN)
num_calls2++; num_calls2++;
} }
if (q && set2 && SET_DEST (set2) == src if (q && set2 && SET_DEST (set2) == src && CONSTANT_P (SET_SRC (set2))
&& CONSTANT_P (SET_SRC (set2)) && validate_change (insn, &SET_SRC (set), XEXP (note, 0), 0))
&& validate_change (insn, &SET_SRC (set),
XEXP (note, 0), 0))
{ {
PUT_CODE (q, NOTE); PUT_CODE (q, NOTE);
NOTE_LINE_NUMBER (q) = NOTE_INSN_DELETED; NOTE_LINE_NUMBER (q) = NOTE_INSN_DELETED;
NOTE_SOURCE_FILE (q) = 0; NOTE_SOURCE_FILE (q) = 0;
REG_N_SETS (REGNO (src))--; REG_N_SETS (REGNO (src))--;
REG_N_CALLS_CROSSED (REGNO (src)) REG_N_CALLS_CROSSED (REGNO (src)) -= num_calls2;
-= num_calls2; REG_N_REFS (REGNO (src)) -= true_loop_depth;
REG_LIVE_LENGTH (REGNO (src)) -= s_length2;
insn_const = 0; insn_const = 0;
} }
} }
} }
if (0) ; if (0) ;
#if defined (HAVE_PRE_INCREMENT) || defined (HAVE_PRE_DECREMENT) #if defined (HAVE_PRE_INCREMENT) || defined (HAVE_PRE_DECREMENT)
else if ((code == PLUS || code == MINUS) else if ((code == PLUS || code == MINUS) && insn_const
&& insn_const && try_auto_increment (p, insn, 0, src, insn_const, 1))
&& try_auto_increment (p, insn, 0,
src, insn_const, 1))
insn = p; insn = p;
#endif #endif
#if defined (HAVE_POST_INCREMENT) || defined (HAVE_POST_DECREMENT) #if defined (HAVE_POST_INCREMENT) || defined (HAVE_POST_DECREMENT)
else if (post_inc else if (post_inc
&& try_auto_increment (p, post_inc, && try_auto_increment (p, post_inc, post_inc_set, src, newconst, 0))
post_inc_set, src,
newconst, 0))
post_inc = 0; post_inc = 0;
#endif #endif
#if defined (HAVE_PRE_INCREMENT) || defined (HAVE_PRE_DECREMENT) #if defined (HAVE_PRE_INCREMENT) || defined (HAVE_PRE_DECREMENT)
...@@ -604,8 +1236,7 @@ regmove_optimize (f, nregs, regmove_dump_file) ...@@ -604,8 +1236,7 @@ regmove_optimize (f, nregs, regmove_dump_file)
If code is MINUS, this was already tried. */ If code is MINUS, this was already tried. */
if (post_inc && code == PLUS if (post_inc && code == PLUS
/* Check that newconst is likely to be usable /* Check that newconst is likely to be usable
in a pre-in/decrement before starting the in a pre-in/decrement before starting the search. */
search. */
&& (0 && (0
#if defined (HAVE_PRE_INCREMENT) #if defined (HAVE_PRE_INCREMENT)
|| (newconst > 0 && newconst <= MOVE_MAX) || (newconst > 0 && newconst <= MOVE_MAX)
...@@ -617,34 +1248,25 @@ regmove_optimize (f, nregs, regmove_dump_file) ...@@ -617,34 +1248,25 @@ regmove_optimize (f, nregs, regmove_dump_file)
{ {
rtx q, inc_dest; rtx q, inc_dest;
inc_dest inc_dest = post_inc_set ? SET_DEST (post_inc_set) : src;
= post_inc_set ? SET_DEST (post_inc_set) : src;
for (q = post_inc; q = NEXT_INSN (q); ) for (q = post_inc; q = NEXT_INSN (q); )
{ {
if (GET_CODE (q) == CODE_LABEL if (GET_CODE (q) == CODE_LABEL || GET_CODE (q) == JUMP_INSN
|| GET_CODE (q) == JUMP_INSN
|| (GET_CODE (q) == NOTE || (GET_CODE (q) == NOTE
&& ((NOTE_LINE_NUMBER (q) && (NOTE_LINE_NUMBER (q) == NOTE_INSN_LOOP_BEG
== NOTE_INSN_LOOP_BEG) || NOTE_LINE_NUMBER (q) == NOTE_INSN_LOOP_END)))
|| (NOTE_LINE_NUMBER (q)
== NOTE_INSN_LOOP_END))))
break; break;
if (GET_RTX_CLASS (GET_CODE (q)) != 'i') if (GET_RTX_CLASS (GET_CODE (q)) != 'i')
continue; continue;
if (src != inc_dest if (src != inc_dest && (reg_overlap_mentioned_p (src, PATTERN (q))
&& (reg_overlap_mentioned_p (src,
PATTERN (q))
|| reg_set_p (src, q))) || reg_set_p (src, q)))
break; break;
if (reg_set_p (inc_dest, q)) if (reg_set_p (inc_dest, q))
break; break;
if (reg_overlap_mentioned_p (inc_dest, if (reg_overlap_mentioned_p (inc_dest, PATTERN (q)))
PATTERN (q)))
{ {
try_auto_increment (q, post_inc, try_auto_increment (q, post_inc,
post_inc_set, post_inc_set, inc_dest, newconst, 1);
inc_dest,
newconst, 1);
break; break;
} }
} }
...@@ -666,7 +1288,7 @@ regmove_optimize (f, nregs, regmove_dump_file) ...@@ -666,7 +1288,7 @@ regmove_optimize (f, nregs, regmove_dump_file)
XEXP (src_note, 1) = REG_NOTES (p); XEXP (src_note, 1) = REG_NOTES (p);
REG_NOTES (p) = src_note; REG_NOTES (p) = src_note;
REG_N_CALLS_CROSSED (REGNO (src)) += num_calls; REG_N_CALLS_CROSSED (REGNO (src)) += s_num_calls;
} }
REG_N_SETS (REGNO (src))++; REG_N_SETS (REGNO (src))++;
...@@ -674,291 +1296,41 @@ regmove_optimize (f, nregs, regmove_dump_file) ...@@ -674,291 +1296,41 @@ regmove_optimize (f, nregs, regmove_dump_file)
REG_N_CALLS_CROSSED (REGNO (dst)) -= num_calls; REG_N_CALLS_CROSSED (REGNO (dst)) -= num_calls;
/* ??? Must adjust reg_live_length, and reg_n_refs for REG_LIVE_LENGTH (REGNO (src)) += s_length;
both registers. Must keep track of loop_depth in if (REG_LIVE_LENGTH (REGNO (dst)) >= 0)
order to get reg_n_refs adjustment correct. */
if (regmove_dump_file)
fprintf (regmove_dump_file,
"Fixed operand %d of insn %d matching operand %d.\n",
operand_number, INSN_UID (insn),
match_number);
goto done_forwards;
}
}
}
done_forwards:
;
}
}
}
/* A backward pass. Replace input operands with output operands. */
if (regmove_dump_file)
fprintf (regmove_dump_file, "Starting backward pass...\n");
for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
{
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
{
int insn_code_number = recog_memoized (insn);
int operand_number, match_number;
if (insn_code_number < 0)
continue;
insn_extract (insn);
if (! constrain_operands (insn_code_number, 0))
continue;
commutative = -1;
/* Must initialize this before the loop, because the code for
the commutative case may set matches for operands other than
the current one. */
bzero ((char *) matches, sizeof (matches));
for (operand_number = 0;
operand_number < insn_n_operands[insn_code_number];
operand_number++)
{
int output_operand = 0;
int matching_operand = operand_number;
char *p, c;
int i = 0;
modified[operand_number] = 0;
early_clobber[operand_number] = 0;
p = insn_operand_constraint[insn_code_number][operand_number];
if (*p == '=')
modified[operand_number] = 2;
else if (*p == '+')
modified[operand_number] = 1;
for (; *p && i < which_alternative; p++)
if (*p == ',')
i++;
while ((c = *p++) != '\0' && c != ',')
switch (c)
{
case '=':
break;
case '+':
break;
case '&':
early_clobber[operand_number] = 1;
break;
case '%':
commutative = operand_number;
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
c -= '0';
matches[c][operand_number] = 1;
if (commutative >= 0)
{
if (c == commutative || c == commutative + 1)
{
int other = c + (c == commutative ? 1 : -1);
matches[other][operand_number] = 1;
}
if (operand_number == commutative
|| operand_number == commutative + 1)
{
int other = (operand_number
+ (operand_number == commutative
? 1 : -1));
matches[c][other] = 1;
}
}
break;
}
}
/* Now scan through the operands looking for a destination operand
which is supposed to match a source operand.
Then scan backward for an instruction which sets the source
operand. If safe, then replace the source operand with the
dest operand in both instructions. */
for (operand_number = 0;
operand_number < insn_n_operands[insn_code_number];
operand_number++)
{
for (match_number = 0;
match_number < insn_n_operands[insn_code_number];
match_number++)
{
rtx set, p, src, dst;
rtx src_note, dst_note;
int success = 0;
int num_calls = 0;
/* Nothing to do if the two operands aren't supposed to
match. */
if (matches[operand_number][match_number] == 0)
continue;
dst = recog_operand[operand_number];
src = recog_operand[match_number];
if (GET_CODE (src) != REG
|| REGNO (src) < FIRST_PSEUDO_REGISTER)
continue;
if (GET_CODE (dst) != REG
|| REGNO (dst) < FIRST_PSEUDO_REGISTER)
continue;
/* If the operands already match, then there is nothing
to do. */
if (operands_match_p (src, dst))
continue;
set = single_set (insn);
if (! set)
continue;
/* operand_number/dst must be a write-only operand, and
match_operand/src must be a read-only operand. */
if (modified[match_number] != 0)
continue;
if (early_clobber[operand_number] == 1)
continue;
if (modified[operand_number] != 2)
continue;
/* Make sure operand_number is the destination. */
if (recog_operand[operand_number] != SET_DEST (set))
continue;
if (! (src_note = find_reg_note (insn, REG_DEAD, src)))
continue;
/* Can not modify an earlier insn to set dst if this insn
uses an old value in the source. */
if (reg_overlap_mentioned_p (dst, SET_SRC (set)))
continue;
if (regmove_dump_file)
fprintf (regmove_dump_file,
"Could fix operand %d of insn %d matching operand %d.\n",
operand_number, INSN_UID (insn), match_number);
/* ??? If src is set once, and is set equal to a constant,
then do not use it for this optimization, as this would
make it no longer equivalent to a constant? */
/* Scan backward to find the first instruction that uses
the input operand. If the operand is set here, then
replace it in both instructions with operand_number. */
for (p = PREV_INSN (insn); p; p = PREV_INSN (p))
{
rtx pset;
if (GET_CODE (p) == CODE_LABEL
|| GET_CODE (p) == JUMP_INSN
|| (GET_CODE (p) == NOTE
&& (NOTE_LINE_NUMBER (p) == NOTE_INSN_LOOP_BEG
|| NOTE_LINE_NUMBER (p) == NOTE_INSN_LOOP_END)))
break;
if (GET_RTX_CLASS (GET_CODE (p)) != 'i')
continue;
/* ??? See if all of SRC is set in P. This test is much
more conservative than it needs to be. */
pset = single_set (p);
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. */
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_operand_loc[operand_number],
dst, 0);
}
}
break;
}
if (reg_overlap_mentioned_p (src, PATTERN (p))
|| reg_overlap_mentioned_p (dst, PATTERN (p)))
break;
/* If we have passed a call instruction, and the
pseudo-reg DST is not already live across a call,
then don't perform the optimization. */
if (GET_CODE (p) == CALL_INSN)
{
num_calls++;
if (REG_N_CALLS_CROSSED (REGNO (dst)) == 0)
break;
}
}
if (success)
{
/* Remove the death note for SRC from INSN. */
remove_note (insn, src_note);
/* Move the death note for SRC to P if it is used
there. */
if (reg_overlap_mentioned_p (src, PATTERN (p)))
{ {
XEXP (src_note, 1) = REG_NOTES (p); REG_LIVE_LENGTH (REGNO (dst)) -= length;
REG_NOTES (p) = src_note; /* REG_LIVE_LENGTH is only an approximation after
combine if sched is not run, so make sure that we
still have a reasonable value. */
if (REG_LIVE_LENGTH (REGNO (dst)) < 2)
REG_LIVE_LENGTH (REGNO (dst)) = 2;
} }
/* If there is a REG_DEAD note for DST on P, then remove
it, because DST is now set there. */
if (dst_note = find_reg_note (p, REG_DEAD, dst))
remove_note (p, dst_note);
REG_N_SETS (REGNO (dst))++; /* We assume that a register is used exactly once per
REG_N_SETS (REGNO (src))--; insn in the updates above. If this is not correct,
no great harm is done. */
REG_N_CALLS_CROSSED (REGNO (dst)) += num_calls; REG_N_REFS (REGNO (src)) += 2 * true_loop_depth;
REG_N_CALLS_CROSSED (REGNO (src)) -= num_calls; REG_N_REFS (REGNO (dst)) -= 2 * true_loop_depth;
/* ??? Must adjust reg_live_length, and reg_n_refs for /* If that was the only time dst was set,
both registers. Must keep track of loop_depth in and dst was not live at the start of the
order to get reg_n_refs adjustment correct. */ function, we know that we have no more
references to dst; clear REG_N_REFS so it
won't make reload do any work. */
if (REG_N_SETS (REGNO (dst)) == 0
&& ! regno_uninitialized (REGNO (dst)))
REG_N_REFS (REGNO (dst)) = 0;
if (regmove_dump_file) if (regmove_dump_file)
fprintf (regmove_dump_file, fprintf (regmove_dump_file,
"Fixed operand %d of insn %d matching operand %d.\n", "Fixed operand %d of insn %d matching operand %d.\n",
operand_number, INSN_UID (insn), match_number); operand_number, INSN_UID (insn), match_number);
return 1;
goto done_backwards;
}
}
}
done_backwards:
;
}
}
#endif /* REGISTER_CONSTRAINTS */
} }
/* return nonzero if X is stable but for mentioning SRC or mentioning / /* return nonzero if X is stable but for mentioning SRC or mentioning /
changing DST . If in doubt, presume it is unstable. */ changing DST . If in doubt, presume it is unstable. */
static int static int
...@@ -985,3 +1357,55 @@ stable_but_for_p (x, src, dst) ...@@ -985,3 +1357,55 @@ stable_but_for_p (x, src, dst)
return ! rtx_unstable_p (x); return ! rtx_unstable_p (x);
} }
} }
/* Test if regmove seems profitable for this target. */
int
regmove_profitable_p ()
{
#ifdef REGISTER_CONSTRAINTS
struct match match;
enum machine_mode mode;
optab tstoptab = add_optab;
do /* check add_optab and ashl_optab */
for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
{
int icode = (int) tstoptab->handlers[(int) mode].insn_code;
rtx reg0, reg1, reg2, pat;
int i;
if (GET_MODE_BITSIZE (mode) < 32 || icode == CODE_FOR_nothing)
continue;
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
if (TEST_HARD_REG_BIT (reg_class_contents[GENERAL_REGS], i))
break;
if (i + 2 >= FIRST_PSEUDO_REGISTER)
break;
reg0 = gen_rtx (REG, insn_operand_mode[icode][0], i);
reg1 = gen_rtx (REG, insn_operand_mode[icode][1], i + 1);
reg2 = gen_rtx (REG, insn_operand_mode[icode][2], i + 2);
if (! (*insn_operand_predicate[icode][0]) (reg0, VOIDmode)
|| ! (*insn_operand_predicate[icode][1]) (reg1, VOIDmode)
|| ! (*insn_operand_predicate[icode][2]) (reg2, VOIDmode))
break;
pat = GEN_FCN (icode) (reg0, reg1, reg2);
if (! pat)
continue;
if (GET_CODE (pat) == SEQUENCE)
pat = XVECEXP (pat, 0, XVECLEN (pat, 0) - 1);
else
pat = make_insn_raw (pat);
if (! single_set (pat)
|| GET_CODE (SET_SRC (single_set (pat))) != tstoptab->code)
/* Unexpected complexity; don't need to handle this unless
we find a machine where this occurs and regmove should
be enabled. */
break;
if (find_matches (pat, &match) >= 0)
return 1;
break;
}
while (tstoptab != ashl_optab && (tstoptab = ashl_optab, 1));
#endif /* REGISTER_CONSTRAINTS */
return 0;
}
gcc/reload.h
/* Communication between reload.c and reload1.c. /* Communication between reload.c and reload1.c.
Copyright (C) 1987, 91, 92, 93, 94, 95, 1997 Free Software Foundation, Inc. Copyright (C) 1987, 91-95, 1997, 1998 Free Software Foundation, Inc.
This file is part of GNU CC. This file is part of GNU CC.
...@@ -200,9 +200,10 @@ extern rtx find_equiv_reg PROTO((rtx, rtx, enum reg_class, int, short *, ...@@ -200,9 +200,10 @@ extern rtx find_equiv_reg PROTO((rtx, rtx, enum reg_class, int, short *,
/* Return 1 if register REGNO is the subject of a clobber in insn INSN. */ /* Return 1 if register REGNO is the subject of a clobber in insn INSN. */
extern int regno_clobbered_p PROTO((int, rtx)); extern int regno_clobbered_p PROTO((int, rtx));
/* Functions in reload1.c: */ /* Functions in reload1.c: */
int count_occurrences PROTO((rtx, rtx));
/* Initialize the reload pass once per compilation. */ /* Initialize the reload pass once per compilation. */
extern void init_reload PROTO((void)); extern void init_reload PROTO((void));
......
gcc/reload1.c
/* Reload pseudo regs into hard regs for insns that require hard regs. /* Reload pseudo regs into hard regs for insns that require hard regs.
Copyright (C) 1987, 88, 89, 92-6, 1997 Free Software Foundation, Inc. Copyright (C) 1987, 88, 89, 92-7 1998 Free Software Foundation, Inc.
This file is part of GNU CC. This file is part of GNU CC.
...@@ -392,7 +392,6 @@ static void emit_reload_insns PROTO((rtx)); ...@@ -392,7 +392,6 @@ static void emit_reload_insns PROTO((rtx));
static void delete_output_reload PROTO((rtx, int, rtx)); static void delete_output_reload PROTO((rtx, int, rtx));
static void inc_for_reload PROTO((rtx, rtx, int)); static void inc_for_reload PROTO((rtx, rtx, int));
static int constraint_accepts_reg_p PROTO((char *, rtx)); static int constraint_accepts_reg_p PROTO((char *, rtx));
static int count_occurrences PROTO((rtx, rtx));
static void reload_cse_invalidate_regno PROTO((int, enum machine_mode, int)); static void reload_cse_invalidate_regno PROTO((int, enum machine_mode, int));
static int reload_cse_mem_conflict_p PROTO((rtx, rtx)); static int reload_cse_mem_conflict_p PROTO((rtx, rtx));
static void reload_cse_invalidate_mem PROTO((rtx)); static void reload_cse_invalidate_mem PROTO((rtx));
...@@ -7510,7 +7509,7 @@ constraint_accepts_reg_p (string, reg) ...@@ -7510,7 +7509,7 @@ constraint_accepts_reg_p (string, reg)
/* Return the number of places FIND appears within X, but don't count /* Return the number of places FIND appears within X, but don't count
an occurrence if some SET_DEST is FIND. */ an occurrence if some SET_DEST is FIND. */
static int int
count_occurrences (x, find) count_occurrences (x, find)
register rtx x, find; register rtx x, find;
{ {
......
gcc/rtl.h
/* Register Transfer Language (RTL) definitions for GNU C-Compiler /* Register Transfer Language (RTL) definitions for GNU C-Compiler
Copyright (C) 1987, 91-96, 1997 Free Software Foundation, Inc. Copyright (C) 1987, 91-97, 1998 Free Software Foundation, Inc.
This file is part of GNU CC. This file is part of GNU CC.
...@@ -1389,4 +1389,8 @@ extern void init_alias_once PROTO ((void)); ...@@ -1389,4 +1389,8 @@ extern void init_alias_once PROTO ((void));
extern void init_alias_analysis PROTO ((void)); extern void init_alias_analysis PROTO ((void));
extern void end_alias_analysis PROTO ((void)); extern void end_alias_analysis PROTO ((void));
/* In local-alloc.c */
extern int optimize_reg_copy_1 PROTO((rtx, rtx, rtx));
extern void optimize_reg_copy_2 PROTO((rtx, rtx, rtx));
#endif /* _RTL_H */ #endif /* _RTL_H */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment