#define STACK_GROWS_DOWNWARD 0
#endif
-/* This structure records stack memory references between stack adjusting
- instructions. */
+/* This structure records two kinds of stack references between stack
+ adjusting instructions: stack references in memory addresses for
+ regular insns and all stack references for debug insns. */
-struct csa_memlist
+struct csa_reflist
{
HOST_WIDE_INT sp_offset;
- rtx insn, *mem;
- struct csa_memlist *next;
+ rtx insn, *ref;
+ struct csa_reflist *next;
};
static int stack_memref_p (rtx);
static rtx single_set_for_csa (rtx);
-static void free_csa_memlist (struct csa_memlist *);
-static struct csa_memlist *record_one_stack_memref (rtx, rtx *,
- struct csa_memlist *);
-static int try_apply_stack_adjustment (rtx, struct csa_memlist *,
+static void free_csa_reflist (struct csa_reflist *);
+static struct csa_reflist *record_one_stack_ref (rtx, rtx *,
+ struct csa_reflist *);
+static int try_apply_stack_adjustment (rtx, struct csa_reflist *,
HOST_WIDE_INT, HOST_WIDE_INT);
static void combine_stack_adjustments_for_block (basic_block);
-static int record_stack_memrefs (rtx *, void *);
+static int record_stack_refs (rtx *, void *);
/* Main entry point for stack adjustment combination. */
return 1;
if (GET_CODE (x) == PLUS
&& XEXP (x, 0) == stack_pointer_rtx
- && GET_CODE (XEXP (x, 1)) == CONST_INT)
+ && CONST_INT_P (XEXP (x, 1)))
return 1;
return 0;
return XVECEXP (tmp, 0, 0);
}
-/* Free the list of csa_memlist nodes. */
+/* Free the list of csa_reflist nodes. */
static void
-free_csa_memlist (struct csa_memlist *memlist)
+free_csa_reflist (struct csa_reflist *reflist)
{
- struct csa_memlist *next;
- for (; memlist ; memlist = next)
+ struct csa_reflist *next;
+ for (; reflist ; reflist = next)
{
- next = memlist->next;
- free (memlist);
+ next = reflist->next;
+ free (reflist);
}
}
-/* Create a new csa_memlist node from the given memory reference.
- It is already known that the memory is stack_memref_p. */
+/* Create a new csa_reflist node from the given stack reference.
+ It is already known that the reference is either a MEM satisfying the
+ predicate stack_memref_p or a REG representing the stack pointer. */
-static struct csa_memlist *
-record_one_stack_memref (rtx insn, rtx *mem, struct csa_memlist *next_memlist)
+static struct csa_reflist *
+record_one_stack_ref (rtx insn, rtx *ref, struct csa_reflist *next_reflist)
{
- struct csa_memlist *ml;
+ struct csa_reflist *ml;
- ml = XNEW (struct csa_memlist);
+ ml = XNEW (struct csa_reflist);
- if (XEXP (*mem, 0) == stack_pointer_rtx)
+ if (REG_P (*ref) || XEXP (*ref, 0) == stack_pointer_rtx)
ml->sp_offset = 0;
else
- ml->sp_offset = INTVAL (XEXP (XEXP (*mem, 0), 1));
+ ml->sp_offset = INTVAL (XEXP (XEXP (*ref, 0), 1));
ml->insn = insn;
- ml->mem = mem;
- ml->next = next_memlist;
+ ml->ref = ref;
+ ml->next = next_reflist;
return ml;
}
/* Attempt to apply ADJUST to the stack adjusting insn INSN, as well
- as each of the memories in MEMLIST. Return true on success. */
+ as each of the memories and stack references in REFLIST. Return true
+ on success. */
static int
-try_apply_stack_adjustment (rtx insn, struct csa_memlist *memlist, HOST_WIDE_INT new_adjust,
- HOST_WIDE_INT delta)
+try_apply_stack_adjustment (rtx insn, struct csa_reflist *reflist,
+ HOST_WIDE_INT new_adjust, HOST_WIDE_INT delta)
{
- struct csa_memlist *ml;
+ struct csa_reflist *ml;
rtx set;
set = single_set_for_csa (insn);
- validate_change (insn, &XEXP (SET_SRC (set), 1), GEN_INT (new_adjust), 1);
+ if (MEM_P (SET_DEST (set)))
+ validate_change (insn, &SET_DEST (set),
+ replace_equiv_address (SET_DEST (set), stack_pointer_rtx),
+ 1);
+ else
+ validate_change (insn, &XEXP (SET_SRC (set), 1), GEN_INT (new_adjust), 1);
+
+ for (ml = reflist; ml ; ml = ml->next)
+ {
+ rtx new_addr = plus_constant (stack_pointer_rtx, ml->sp_offset - delta);
+ rtx new_val;
- for (ml = memlist; ml ; ml = ml->next)
- validate_change
- (ml->insn, ml->mem,
- replace_equiv_address_nv (*ml->mem,
- plus_constant (stack_pointer_rtx,
- ml->sp_offset - delta)), 1);
+ if (MEM_P (*ml->ref))
+ new_val = replace_equiv_address_nv (*ml->ref, new_addr);
+ else if (GET_MODE (*ml->ref) == GET_MODE (stack_pointer_rtx))
+ new_val = new_addr;
+ else
+ new_val = lowpart_subreg (GET_MODE (*ml->ref), new_addr,
+ GET_MODE (new_addr));
+ validate_change (ml->insn, ml->ref, new_val, 1);
+ }
if (apply_change_group ())
{
- /* Succeeded. Update our knowledge of the memory references. */
- for (ml = memlist; ml ; ml = ml->next)
+ /* Succeeded. Update our knowledge of the stack references. */
+ for (ml = reflist; ml ; ml = ml->next)
ml->sp_offset -= delta;
return 1;
return 0;
}
-/* Called via for_each_rtx and used to record all stack memory references in
- the insn and discard all other stack pointer references. */
-struct record_stack_memrefs_data
+/* Called via for_each_rtx and used to record all stack memory and other
+ references in the insn and discard all other stack pointer references. */
+struct record_stack_refs_data
{
rtx insn;
- struct csa_memlist *memlist;
+ struct csa_reflist *reflist;
};
static int
-record_stack_memrefs (rtx *xp, void *data)
+record_stack_refs (rtx *xp, void *data)
{
rtx x = *xp;
- struct record_stack_memrefs_data *d =
- (struct record_stack_memrefs_data *) data;
+ struct record_stack_refs_data *d =
+ (struct record_stack_refs_data *) data;
if (!x)
return 0;
switch (GET_CODE (x))
stack pointer, so this check is necessary. */
if (stack_memref_p (x))
{
- d->memlist = record_one_stack_memref (d->insn, xp, d->memlist);
+ d->reflist = record_one_stack_ref (d->insn, xp, d->reflist);
return -1;
}
- return 1;
+ /* Try harder for DEBUG_INSNs, handle e.g. (mem (mem (sp + 16) + 4). */
+ return !DEBUG_INSN_P (d->insn);
case REG:
/* ??? We want be able to handle non-memory stack pointer
references later. For now just discard all insns referring to
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 explicit clobber in an asm statement will
- result in a QImode clobber. */
+ result in a QImode clobber.
+
+ In DEBUG_INSNs, we want to replace all occurrences, otherwise
+ they will cause -fcompare-debug failures. */
if (REGNO (x) == STACK_POINTER_REGNUM)
- return 1;
+ {
+ if (!DEBUG_INSN_P (d->insn))
+ return 1;
+ d->reflist = record_one_stack_ref (d->insn, xp, d->reflist);
+ return -1;
+ }
break;
default:
break;
&& SET_DEST (last) == stack_pointer_rtx
&& GET_CODE (SET_SRC (last)) == PLUS
&& XEXP (SET_SRC (last), 0) == stack_pointer_rtx
- && GET_CODE (XEXP (SET_SRC (last), 1)) == CONST_INT)
+ && CONST_INT_P (XEXP (SET_SRC (last), 1)))
{
XEXP (SET_SRC (last), 1)
= GEN_INT (INTVAL (XEXP (SET_SRC (last), 1)) + this_adjust);
{
HOST_WIDE_INT last_sp_adjust = 0;
rtx last_sp_set = NULL_RTX;
- struct csa_memlist *memlist = NULL;
+ struct csa_reflist *reflist = NULL;
rtx insn, next, set;
- struct record_stack_memrefs_data data;
+ struct record_stack_refs_data data;
bool end_of_block = false;
for (insn = BB_HEAD (bb); !end_of_block ; insn = next)
if (dest == stack_pointer_rtx
&& GET_CODE (src) == PLUS
&& XEXP (src, 0) == stack_pointer_rtx
- && GET_CODE (XEXP (src, 1)) == CONST_INT)
+ && CONST_INT_P (XEXP (src, 1)))
{
HOST_WIDE_INT this_adjust = INTVAL (XEXP (src, 1));
continue;
}
- /* If not all recorded memrefs can be adjusted, or the
+ /* If not all recorded refs can be adjusted, or the
adjustment is now too large for a constant addition,
we cannot merge the two stack adjustments.
/* Combine an allocation into the first instruction. */
if (STACK_GROWS_DOWNWARD ? this_adjust <= 0 : this_adjust >= 0)
{
- if (try_apply_stack_adjustment (last_sp_set, memlist,
+ if (try_apply_stack_adjustment (last_sp_set, reflist,
last_sp_adjust + this_adjust,
this_adjust))
{
else if (STACK_GROWS_DOWNWARD
? last_sp_adjust >= 0 : last_sp_adjust <= 0)
{
- if (try_apply_stack_adjustment (insn, memlist,
+ if (try_apply_stack_adjustment (insn, reflist,
last_sp_adjust + this_adjust,
-last_sp_adjust))
{
delete_insn (last_sp_set);
last_sp_set = insn;
last_sp_adjust += this_adjust;
- free_csa_memlist (memlist);
- memlist = NULL;
+ free_csa_reflist (reflist);
+ reflist = NULL;
continue;
}
}
delete the old deallocation insn. */
if (last_sp_set && last_sp_adjust == 0)
delete_insn (last_sp_set);
- free_csa_memlist (memlist);
- memlist = NULL;
+ free_csa_reflist (reflist);
+ reflist = NULL;
last_sp_set = insn;
last_sp_adjust = this_adjust;
continue;
}
- /* Find a predecrement of exactly the previous adjustment and
- turn it into a direct store. Obviously we can't do this if
- there were any intervening uses of the stack pointer. */
- if (memlist == NULL
- && MEM_P (dest)
- && ((GET_CODE (XEXP (dest, 0)) == PRE_DEC
- && (last_sp_adjust
- == (HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (dest))))
- || (GET_CODE (XEXP (dest, 0)) == PRE_MODIFY
+ /* Find a store with pre-(dec|inc)rement or pre-modify of exactly
+ the previous adjustment and turn it into a simple store. This
+ is equivalent to anticipating the stack adjustment so this must
+ be an allocation. */
+ if (MEM_P (dest)
+ && ((STACK_GROWS_DOWNWARD
+ ? (GET_CODE (XEXP (dest, 0)) == PRE_DEC
+ && last_sp_adjust
+ == (HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (dest)))
+ : (GET_CODE (XEXP (dest, 0)) == PRE_INC
+ && last_sp_adjust
+ == -(HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (dest))))
+ || ((STACK_GROWS_DOWNWARD
+ ? last_sp_adjust >= 0 : last_sp_adjust <= 0)
+ && GET_CODE (XEXP (dest, 0)) == PRE_MODIFY
&& GET_CODE (XEXP (XEXP (dest, 0), 1)) == PLUS
- && XEXP (XEXP (XEXP (dest, 0), 1), 0) == stack_pointer_rtx
- && (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
- == CONST_INT)
- && (INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1))
- == -last_sp_adjust)))
+ && XEXP (XEXP (XEXP (dest, 0), 1), 0)
+ == stack_pointer_rtx
+ && GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
+ == CONST_INT
+ && INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1))
+ == -last_sp_adjust))
&& XEXP (XEXP (dest, 0), 0) == stack_pointer_rtx
- && ! reg_mentioned_p (stack_pointer_rtx, src)
+ && !reg_mentioned_p (stack_pointer_rtx, src)
&& memory_address_p (GET_MODE (dest), stack_pointer_rtx)
- && validate_change (insn, &SET_DEST (set),
- replace_equiv_address (dest,
- stack_pointer_rtx),
- 0))
+ && try_apply_stack_adjustment (insn, reflist, 0,
+ -last_sp_adjust))
{
delete_insn (last_sp_set);
- free_csa_memlist (memlist);
- memlist = NULL;
+ free_csa_reflist (reflist);
+ reflist = NULL;
last_sp_set = NULL_RTX;
last_sp_adjust = 0;
continue;
}
data.insn = insn;
- data.memlist = memlist;
+ data.reflist = reflist;
if (!CALL_P (insn) && last_sp_set
- && !for_each_rtx (&PATTERN (insn), record_stack_memrefs, &data))
+ && !for_each_rtx (&PATTERN (insn), record_stack_refs, &data))
{
- memlist = data.memlist;
+ reflist = data.reflist;
continue;
}
- memlist = data.memlist;
+ reflist = data.reflist;
/* Otherwise, we were not able to process the instruction.
Do not continue collecting data across such a one. */
{
if (last_sp_set && last_sp_adjust == 0)
delete_insn (last_sp_set);
- free_csa_memlist (memlist);
- memlist = NULL;
+ free_csa_reflist (reflist);
+ reflist = NULL;
last_sp_set = NULL_RTX;
last_sp_adjust = 0;
}
if (last_sp_set && last_sp_adjust == 0)
delete_insn (last_sp_set);
- if (memlist)
- free_csa_memlist (memlist);
+ if (reflist)
+ free_csa_reflist (reflist);
}
\f
NULL, /* sub */
NULL, /* next */
0, /* static_pass_number */
- 0, /* tv_id */
+ TV_COMBINE_STACK_ADJUST, /* tv_id */
0, /* properties_required */
0, /* properties_provided */
0, /* properties_destroyed */
OSDN Git Service
