Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
1999, 2000, 2001 Free Software Foundation, Inc.
-This file is part of GNU CC.
+This file is part of GCC.
-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.
+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
+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.
+GCC 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
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+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. */
/* This module looks for cases where matching constraints would force
#include "basic-block.h"
#include "except.h"
#include "toplev.h"
+#include "reload.h"
+
+
+/* Turn STACK_GROWS_DOWNWARD into a boolean. */
+#ifdef STACK_GROWS_DOWNWARD
+#undef STACK_GROWS_DOWNWARD
+#define STACK_GROWS_DOWNWARD 1
+#else
+#define STACK_GROWS_DOWNWARD 0
+#endif
static int perhaps_ends_bb_p PARAMS ((rtx));
static int optimize_reg_copy_1 PARAMS ((rtx, rtx, rtx));
static void optimize_reg_copy_2 PARAMS ((rtx, rtx, rtx));
static void optimize_reg_copy_3 PARAMS ((rtx, rtx, rtx));
-static rtx gen_add3_insn PARAMS ((rtx, rtx, rtx));
static void copy_src_to_dest PARAMS ((rtx, rtx, rtx, int));
static int *regmove_bb_head;
static int try_auto_increment PARAMS ((rtx, rtx, rtx, rtx, HOST_WIDE_INT, int));
static int find_matches PARAMS ((rtx, struct match *));
-static void replace_in_call_usage PARAMS ((rtx *, int, rtx, rtx));
+static void replace_in_call_usage PARAMS ((rtx *, unsigned int, rtx, rtx));
static int fixup_match_1 PARAMS ((rtx, rtx, rtx, rtx, rtx, int, int, int, FILE *))
;
static int reg_is_remote_constant_p PARAMS ((rtx, rtx, rtx));
&& ! CLASS_LIKELY_SPILLED_P (class1)));
}
-/* Generate and return an insn body to add r1 and c,
- storing the result in r0. */
-static rtx
-gen_add3_insn (r0, r1, c)
- rtx r0, r1, c;
-{
- int icode = (int) add_optab->handlers[(int) GET_MODE (r0)].insn_code;
-
- if (icode == CODE_FOR_nothing
- || ! ((*insn_data[icode].operand[0].predicate)
- (r0, insn_data[icode].operand[0].mode))
- || ! ((*insn_data[icode].operand[1].predicate)
- (r1, insn_data[icode].operand[1].mode))
- || ! ((*insn_data[icode].operand[2].predicate)
- (c, insn_data[icode].operand[2].mode)))
- return NULL_RTX;
-
- return (GEN_FCN (icode) (r0, r1, c));
-}
-
-
/* INC_INSN is an instruction that adds INCREMENT to REG.
Try to fold INC_INSN as a post/pre in/decrement into INSN.
Iff INC_INSN_SET is nonzero, inc_insn has a destination different from src.
int sregno = REGNO (src);
int dregno = REGNO (dest);
- /* We don't want to mess with hard regs if register classes are small. */
+ /* We don't want to mess with hard regs if register classes are small. */
if (sregno == dregno
|| (SMALL_REGISTER_CLASSES
&& (sregno < FIRST_PSEUDO_REGISTER
if (! (set = single_set (p))
|| GET_CODE (SET_SRC (set)) != MEM
+ /* If there's a REG_EQUIV note, this must be an insn that loads an
+ argument. Prefer keeping the note over doing this optimization. */
+ || find_reg_note (p, REG_EQUIV, NULL_RTX)
|| SET_DEST (set) != src_reg)
return;
PUT_MODE (src_reg, old_mode);
XEXP (src, 0) = src_reg;
}
+ else
+ {
+ rtx note = find_reg_note (p, REG_EQUAL, NULL_RTX);
+ if (note)
+ remove_note (p, note);
+ }
}
\f
return 0;
}
+/* Main entry for the register move optimization.
+ F is the first instruction.
+ NREGS is one plus the highest pseudo-reg number used in the instruction.
+ REGMOVE_DUMP_FILE is a stream for output of a trace of actions taken
+ (or 0 if none should be output). */
+
void
regmove_optimize (f, nregs, regmove_dump_file)
rtx f;
if (recog_data.operand[match_no] != SET_DEST (set))
continue;
- /* If the operands already match, then there is nothing to do. */
+ /* If the operands already match, then there is nothing to do. */
if (operands_match_p (src, dst))
continue;
if (! regclass_compatible_p (src_class, dst_class))
continue;
+ if (GET_MODE (src) != GET_MODE (dst))
+ continue;
+
if (fixup_match_1 (insn, set, src, src_subreg, dst, pass,
op_no, match_no,
regmove_dump_file))
if (GET_CODE (dst) != REG
|| REGNO (dst) < FIRST_PSEUDO_REGISTER
- || REG_LIVE_LENGTH (REGNO (dst)) < 0)
+ || REG_LIVE_LENGTH (REGNO (dst)) < 0
+ || RTX_UNCHANGING_P (dst))
continue;
- /* If the operands already match, then there is nothing to do. */
+ /* If the operands already match, then there is nothing to do. */
if (operands_match_p (src, dst))
continue;
if (! set)
continue;
+ /* Note that single_set ignores parts of a parallel set for
+ which one of the destinations is REG_UNUSED. We can't
+ handle that here, since we can wind up rewriting things
+ such that a single register is set twice within a single
+ parallel. */
+ if (reg_set_p (src, insn))
+ continue;
+
/* match_no/dst must be a write-only operand, and
operand_operand/src must be a read-only operand. */
if (match.use[op_no] != READ
static void
replace_in_call_usage (loc, dst_reg, src, insn)
rtx *loc;
- int dst_reg;
+ unsigned int dst_reg;
rtx src;
rtx insn;
{
{
/* ??? We can't scan past the end of a basic block without updating
the register lifetime info
- (REG_DEAD/basic_block_live_at_start). */
+ (REG_DEAD/basic_block_live_at_start). */
if (perhaps_ends_bb_p (q))
break;
else if (! INSN_P (q))
struct csa_memlist *ml;
rtx set;
- /* We know INSN matches single_set_for_csa, because that's what we
- recognized earlier. However, if INSN is not single_set, it is
- doing double duty as a barrier for frame pointer memory accesses,
- which we are not recording. Therefore, an adjust insn that is not
- single_set may not have a positive delta applied. */
-
- if (delta > 0 && ! single_set (insn))
- return 0;
set = single_set_for_csa (insn);
validate_change (insn, &XEXP (SET_SRC (set), 1), GEN_INT (new_adjust), 1);
for (ml = memlist; ml ; ml = ml->next)
- {
- HOST_WIDE_INT c = ml->sp_offset - delta;
- rtx new = gen_rtx_MEM (GET_MODE (*ml->mem),
- plus_constant (stack_pointer_rtx, c));
-
- /* Don't reference memory below the stack pointer. */
- if (c < 0)
- {
- cancel_changes (0);
- return 0;
- }
-
- MEM_COPY_ATTRIBUTES (new, *ml->mem);
- validate_change (ml->insn, ml->mem, new, 1);
- }
+ validate_change
+ (ml->insn, ml->mem,
+ replace_equiv_address_nv (*ml->mem,
+ plus_constant (stack_pointer_rtx,
+ ml->sp_offset - delta)), 1);
if (apply_change_group ())
{
}
return 1;
case REG:
- /* ??? We want be able to handle non-memory stack pointer references
- later. For now just discard all insns refering to stack pointer
- outside mem expressions. We would probably want to teach
- validate_replace to simplify expressions first. */
- if (x == stack_pointer_rtx)
+ /* ??? We want be able to handle non-memory stack pointer
+ references later. For now just discard all insns refering to
+ stack pointer outside mem expressions. We would probably
+ want to teach validate_replace to simplify expressions first.
+
+ We can't just compare with STACK_POINTER_RTX because the
+ reference to the stack pointer might be in some other mode.
+ In particular, an explict clobber in an asm statement will
+ result in a QImode clober. */
+ if (REGNO (x) == STACK_POINTER_REGNUM)
return 1;
break;
default:
/* If not all recorded memrefs can be adjusted, or the
adjustment is now too large for a constant addition,
- we cannot merge the two stack adjustments. */
- if (! try_apply_stack_adjustment (last_sp_set, memlist,
- last_sp_adjust + this_adjust,
- this_adjust))
+ we cannot merge the two stack adjustments.
+
+ Also we need to be carefull to not move stack pointer
+ such that we create stack accesses outside the allocated
+ area. We can combine an allocation into the first insn,
+ or a deallocation into the second insn. We can not
+ combine an allocation followed by a deallocation.
+
+ The only somewhat frequent ocurrence of the later is when
+ a function allocates a stack frame but does not use it.
+ For this case, we would need to analyze rtl stream to be
+ sure that allocated area is really unused. This means not
+ only checking the memory references, but also all registers
+ or global memory references possibly containing a stack
+ frame address.
+
+ Perhaps the best way to address this problem is to teach
+ gcc not to allocate stack for objects never used. */
+
+ /* Combine an allocation into the first instruction. */
+ if (STACK_GROWS_DOWNWARD ? this_adjust <= 0 : this_adjust >= 0)
{
- free_csa_memlist (memlist);
- memlist = NULL;
- last_sp_set = insn;
- last_sp_adjust = this_adjust;
- goto processed;
+ if (try_apply_stack_adjustment (last_sp_set, memlist,
+ last_sp_adjust + this_adjust,
+ this_adjust))
+ {
+ /* It worked! */
+ pending_delete = insn;
+ last_sp_adjust += this_adjust;
+ goto processed;
+ }
}
- /* It worked! */
- pending_delete = insn;
- last_sp_adjust += this_adjust;
-
- /* If, by some accident, the adjustments cancel out,
- delete both insns and start from scratch. */
- if (last_sp_adjust == 0)
+ /* Otherwise we have a deallocation. Do not combine with
+ a previous allocation. Combine into the second insn. */
+ else if (STACK_GROWS_DOWNWARD
+ ? last_sp_adjust >= 0 : last_sp_adjust <= 0)
{
- if (last_sp_set == bb->head)
- bb->head = NEXT_INSN (last_sp_set);
- flow_delete_insn (last_sp_set);
-
- free_csa_memlist (memlist);
- memlist = NULL;
- last_sp_set = NULL_RTX;
+ if (try_apply_stack_adjustment (insn, memlist,
+ last_sp_adjust + this_adjust,
+ -last_sp_adjust))
+ {
+ /* It worked! */
+ flow_delete_insn (last_sp_set);
+ last_sp_set = insn;
+ last_sp_adjust += this_adjust;
+ free_csa_memlist (memlist);
+ memlist = NULL;
+ goto processed;
+ }
}
+ /* Combination failed. Restart processing from here. */
+ free_csa_memlist (memlist);
+ memlist = NULL;
+ last_sp_set = insn;
+ last_sp_adjust = this_adjust;
goto processed;
}
&& ! reg_mentioned_p (stack_pointer_rtx, src)
&& memory_address_p (GET_MODE (dest), stack_pointer_rtx)
&& validate_change (insn, &SET_DEST (set),
- change_address (dest, VOIDmode,
- stack_pointer_rtx), 0))
+ replace_equiv_address (dest,
+ stack_pointer_rtx),
+ 0))
{
if (last_sp_set == bb->head)
bb->head = NEXT_INSN (last_sp_set);