1 /* Combine stack adjustments.
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
4 2010 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* Track stack adjustments and stack memory references. Attempt to
23 reduce the number of stack adjustments by back-propagating across
24 the memory references.
26 This is intended primarily for use with targets that do not define
27 ACCUMULATE_OUTGOING_ARGS. It is of significantly more value to
28 targets that define PREFERRED_STACK_BOUNDARY more aligned than
29 STACK_BOUNDARY (e.g. x86), or if not all registers can be pushed
30 (e.g. x86 fp regs) which would ordinarily have to be implemented
31 as a sub/mov pair due to restrictions in calls.c.
33 Propagation stops when any of the insns that need adjusting are
34 (a) no longer valid because we've exceeded their range, (b) a
35 non-trivial push instruction, or (c) a call instruction.
37 Restriction B is based on the assumption that push instructions
38 are smaller or faster. If a port really wants to remove all
39 pushes, it should have defined ACCUMULATE_OUTGOING_ARGS. The
40 one exception that is made is for an add immediately followed
45 #include "coretypes.h"
49 #include "insn-config.h"
53 #include "hard-reg-set.h"
57 #include "basic-block.h"
62 #include "tree-pass.h"
65 /* Turn STACK_GROWS_DOWNWARD into a boolean. */
66 #ifdef STACK_GROWS_DOWNWARD
67 #undef STACK_GROWS_DOWNWARD
68 #define STACK_GROWS_DOWNWARD 1
70 #define STACK_GROWS_DOWNWARD 0
73 /* This structure records two kinds of stack references between stack
74 adjusting instructions: stack references in memory addresses for
75 regular insns and all stack references for debug insns. */
79 HOST_WIDE_INT sp_offset;
81 struct csa_reflist *next;
84 static int stack_memref_p (rtx);
85 static rtx single_set_for_csa (rtx);
86 static void free_csa_reflist (struct csa_reflist *);
87 static struct csa_reflist *record_one_stack_ref (rtx, rtx *,
88 struct csa_reflist *);
89 static int try_apply_stack_adjustment (rtx, struct csa_reflist *,
90 HOST_WIDE_INT, HOST_WIDE_INT);
91 static void combine_stack_adjustments_for_block (basic_block);
92 static int record_stack_refs (rtx *, void *);
95 /* Main entry point for stack adjustment combination. */
98 combine_stack_adjustments (void)
103 combine_stack_adjustments_for_block (bb);
106 /* Recognize a MEM of the form (sp) or (plus sp const). */
109 stack_memref_p (rtx x)
115 if (x == stack_pointer_rtx)
117 if (GET_CODE (x) == PLUS
118 && XEXP (x, 0) == stack_pointer_rtx
119 && CONST_INT_P (XEXP (x, 1)))
125 /* Recognize either normal single_set or the hack in i386.md for
126 tying fp and sp adjustments. */
129 single_set_for_csa (rtx insn)
132 rtx tmp = single_set (insn);
136 if (!NONJUMP_INSN_P (insn)
137 || GET_CODE (PATTERN (insn)) != PARALLEL)
140 tmp = PATTERN (insn);
141 if (GET_CODE (XVECEXP (tmp, 0, 0)) != SET)
144 for (i = 1; i < XVECLEN (tmp, 0); ++i)
146 rtx this_rtx = XVECEXP (tmp, 0, i);
148 /* The special case is allowing a no-op set. */
149 if (GET_CODE (this_rtx) == SET
150 && SET_SRC (this_rtx) == SET_DEST (this_rtx))
152 else if (GET_CODE (this_rtx) != CLOBBER
153 && GET_CODE (this_rtx) != USE)
157 return XVECEXP (tmp, 0, 0);
160 /* Free the list of csa_reflist nodes. */
163 free_csa_reflist (struct csa_reflist *reflist)
165 struct csa_reflist *next;
166 for (; reflist ; reflist = next)
168 next = reflist->next;
173 /* Create a new csa_reflist node from the given stack reference.
174 It is already known that the reference is either a MEM satisfying the
175 predicate stack_memref_p or a REG representing the stack pointer. */
177 static struct csa_reflist *
178 record_one_stack_ref (rtx insn, rtx *ref, struct csa_reflist *next_reflist)
180 struct csa_reflist *ml;
182 ml = XNEW (struct csa_reflist);
184 if (REG_P (*ref) || XEXP (*ref, 0) == stack_pointer_rtx)
187 ml->sp_offset = INTVAL (XEXP (XEXP (*ref, 0), 1));
191 ml->next = next_reflist;
196 /* Attempt to apply ADJUST to the stack adjusting insn INSN, as well
197 as each of the memories and stack references in REFLIST. Return true
201 try_apply_stack_adjustment (rtx insn, struct csa_reflist *reflist,
202 HOST_WIDE_INT new_adjust, HOST_WIDE_INT delta)
204 struct csa_reflist *ml;
207 set = single_set_for_csa (insn);
208 if (MEM_P (SET_DEST (set)))
209 validate_change (insn, &SET_DEST (set),
210 replace_equiv_address (SET_DEST (set), stack_pointer_rtx),
213 validate_change (insn, &XEXP (SET_SRC (set), 1), GEN_INT (new_adjust), 1);
215 for (ml = reflist; ml ; ml = ml->next)
217 rtx new_addr = plus_constant (stack_pointer_rtx, ml->sp_offset - delta);
220 if (MEM_P (*ml->ref))
221 new_val = replace_equiv_address_nv (*ml->ref, new_addr);
222 else if (GET_MODE (*ml->ref) == GET_MODE (stack_pointer_rtx))
225 new_val = lowpart_subreg (GET_MODE (*ml->ref), new_addr,
226 GET_MODE (new_addr));
227 validate_change (ml->insn, ml->ref, new_val, 1);
230 if (apply_change_group ())
232 /* Succeeded. Update our knowledge of the stack references. */
233 for (ml = reflist; ml ; ml = ml->next)
234 ml->sp_offset -= delta;
242 /* Called via for_each_rtx and used to record all stack memory and other
243 references in the insn and discard all other stack pointer references. */
244 struct record_stack_refs_data
247 struct csa_reflist *reflist;
251 record_stack_refs (rtx *xp, void *data)
254 struct record_stack_refs_data *d =
255 (struct record_stack_refs_data *) data;
258 switch (GET_CODE (x))
261 if (!reg_mentioned_p (stack_pointer_rtx, x))
263 /* We are not able to handle correctly all possible memrefs containing
264 stack pointer, so this check is necessary. */
265 if (stack_memref_p (x))
267 d->reflist = record_one_stack_ref (d->insn, xp, d->reflist);
270 /* Try harder for DEBUG_INSNs, handle e.g. (mem (mem (sp + 16) + 4). */
271 return !DEBUG_INSN_P (d->insn);
273 /* ??? We want be able to handle non-memory stack pointer
274 references later. For now just discard all insns referring to
275 stack pointer outside mem expressions. We would probably
276 want to teach validate_replace to simplify expressions first.
278 We can't just compare with STACK_POINTER_RTX because the
279 reference to the stack pointer might be in some other mode.
280 In particular, an explicit clobber in an asm statement will
281 result in a QImode clobber.
283 In DEBUG_INSNs, we want to replace all occurrences, otherwise
284 they will cause -fcompare-debug failures. */
285 if (REGNO (x) == STACK_POINTER_REGNUM)
287 if (!DEBUG_INSN_P (d->insn))
289 d->reflist = record_one_stack_ref (d->insn, xp, d->reflist);
299 /* If INSN has a REG_ARGS_SIZE note, move it to LAST.
300 AFTER is true iff LAST follows INSN in the instruction stream. */
303 maybe_move_args_size_note (rtx last, rtx insn, bool after)
307 note = find_reg_note (insn, REG_ARGS_SIZE, NULL_RTX);
311 last_note = find_reg_note (last, REG_ARGS_SIZE, NULL_RTX);
314 /* The ARGS_SIZE notes are *not* cumulative. They represent an
315 absolute value, and the "most recent" note wins. */
317 XEXP (last_note, 0) = XEXP (note, 0);
320 add_reg_note (last, REG_ARGS_SIZE, XEXP (note, 0));
323 /* Return the next (or previous) active insn within BB. */
326 prev_active_insn_bb (basic_block bb, rtx insn)
328 for (insn = PREV_INSN (insn);
329 insn != PREV_INSN (BB_HEAD (bb));
330 insn = PREV_INSN (insn))
331 if (active_insn_p (insn))
337 next_active_insn_bb (basic_block bb, rtx insn)
339 for (insn = NEXT_INSN (insn);
340 insn != NEXT_INSN (BB_END (bb));
341 insn = NEXT_INSN (insn))
342 if (active_insn_p (insn))
347 /* If INSN has a REG_ARGS_SIZE note, if possible move it to PREV. Otherwise
348 search for a nearby candidate within BB where we can stick the note. */
351 force_move_args_size_note (basic_block bb, rtx prev, rtx insn)
353 rtx note, test, next_candidate, prev_candidate;
355 /* If PREV exists, tail-call to the logic in the other function. */
358 maybe_move_args_size_note (prev, insn, false);
362 /* First, make sure there's anything that needs doing. */
363 note = find_reg_note (insn, REG_ARGS_SIZE, NULL_RTX);
367 /* We need to find a spot between the previous and next exception points
368 where we can place the note and "properly" deallocate the arguments. */
369 next_candidate = prev_candidate = NULL;
371 /* It is often the case that we have insns in the order:
373 add sp (previous deallocation)
374 sub sp (align for next arglist)
376 and the add/sub cancel. Therefore we begin by searching forward. */
379 while ((test = next_active_insn_bb (bb, test)) != NULL)
381 /* Found an existing note: nothing to do. */
382 if (find_reg_note (test, REG_ARGS_SIZE, NULL_RTX))
384 /* Found something that affects unwinding. Stop searching. */
385 if (CALL_P (test) || !insn_nothrow_p (test))
387 if (next_candidate == NULL)
388 next_candidate = test;
392 while ((test = prev_active_insn_bb (bb, test)) != NULL)
395 /* Found a place that seems logical to adjust the stack. */
396 tnote = find_reg_note (test, REG_ARGS_SIZE, NULL_RTX);
399 XEXP (tnote, 0) = XEXP (note, 0);
402 if (prev_candidate == NULL)
403 prev_candidate = test;
404 /* Found something that affects unwinding. Stop searching. */
405 if (CALL_P (test) || !insn_nothrow_p (test))
410 test = prev_candidate;
411 else if (next_candidate)
412 test = next_candidate;
415 /* ??? We *must* have a place, lest we ICE on the lost adjustment.
416 Options are: dummy clobber insn, nop, or prevent the removal of
417 the sp += 0 insn. Defer that decision until we can prove this
418 can actually happen. */
421 add_reg_note (test, REG_ARGS_SIZE, XEXP (note, 0));
424 /* Subroutine of combine_stack_adjustments, called for each basic block. */
427 combine_stack_adjustments_for_block (basic_block bb)
429 HOST_WIDE_INT last_sp_adjust = 0;
430 rtx last_sp_set = NULL_RTX;
431 rtx last2_sp_set = NULL_RTX;
432 struct csa_reflist *reflist = NULL;
434 struct record_stack_refs_data data;
435 bool end_of_block = false;
437 for (insn = BB_HEAD (bb); !end_of_block ; insn = next)
439 end_of_block = insn == BB_END (bb);
440 next = NEXT_INSN (insn);
445 set = single_set_for_csa (insn);
448 rtx dest = SET_DEST (set);
449 rtx src = SET_SRC (set);
451 /* Find constant additions to the stack pointer. */
452 if (dest == stack_pointer_rtx
453 && GET_CODE (src) == PLUS
454 && XEXP (src, 0) == stack_pointer_rtx
455 && CONST_INT_P (XEXP (src, 1)))
457 HOST_WIDE_INT this_adjust = INTVAL (XEXP (src, 1));
459 /* If we've not seen an adjustment previously, record
460 it now and continue. */
464 last_sp_adjust = this_adjust;
468 /* If not all recorded refs can be adjusted, or the
469 adjustment is now too large for a constant addition,
470 we cannot merge the two stack adjustments.
472 Also we need to be careful to not move stack pointer
473 such that we create stack accesses outside the allocated
474 area. We can combine an allocation into the first insn,
475 or a deallocation into the second insn. We can not
476 combine an allocation followed by a deallocation.
478 The only somewhat frequent occurrence of the later is when
479 a function allocates a stack frame but does not use it.
480 For this case, we would need to analyze rtl stream to be
481 sure that allocated area is really unused. This means not
482 only checking the memory references, but also all registers
483 or global memory references possibly containing a stack
486 Perhaps the best way to address this problem is to teach
487 gcc not to allocate stack for objects never used. */
489 /* Combine an allocation into the first instruction. */
490 if (STACK_GROWS_DOWNWARD ? this_adjust <= 0 : this_adjust >= 0)
492 if (try_apply_stack_adjustment (last_sp_set, reflist,
493 last_sp_adjust + this_adjust,
497 maybe_move_args_size_note (last_sp_set, insn, false);
499 last_sp_adjust += this_adjust;
504 /* Otherwise we have a deallocation. Do not combine with
505 a previous allocation. Combine into the second insn. */
506 else if (STACK_GROWS_DOWNWARD
507 ? last_sp_adjust >= 0 : last_sp_adjust <= 0)
509 if (try_apply_stack_adjustment (insn, reflist,
510 last_sp_adjust + this_adjust,
514 maybe_move_args_size_note (insn, last_sp_set, true);
515 delete_insn (last_sp_set);
517 last_sp_adjust += this_adjust;
518 free_csa_reflist (reflist);
524 /* Combination failed. Restart processing from here. If
525 deallocation+allocation conspired to cancel, we can
526 delete the old deallocation insn. */
529 if (last_sp_adjust == 0)
531 maybe_move_args_size_note (insn, last_sp_set, true);
532 delete_insn (last_sp_set);
535 last2_sp_set = last_sp_set;
537 free_csa_reflist (reflist);
540 last_sp_adjust = this_adjust;
544 /* Find a store with pre-(dec|inc)rement or pre-modify of exactly
545 the previous adjustment and turn it into a simple store. This
546 is equivalent to anticipating the stack adjustment so this must
549 && ((STACK_GROWS_DOWNWARD
550 ? (GET_CODE (XEXP (dest, 0)) == PRE_DEC
552 == (HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (dest)))
553 : (GET_CODE (XEXP (dest, 0)) == PRE_INC
555 == -(HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (dest))))
556 || ((STACK_GROWS_DOWNWARD
557 ? last_sp_adjust >= 0 : last_sp_adjust <= 0)
558 && GET_CODE (XEXP (dest, 0)) == PRE_MODIFY
559 && GET_CODE (XEXP (XEXP (dest, 0), 1)) == PLUS
560 && XEXP (XEXP (XEXP (dest, 0), 1), 0)
562 && GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
564 && INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1))
566 && XEXP (XEXP (dest, 0), 0) == stack_pointer_rtx
567 && !reg_mentioned_p (stack_pointer_rtx, src)
568 && memory_address_p (GET_MODE (dest), stack_pointer_rtx)
569 && try_apply_stack_adjustment (insn, reflist, 0,
573 maybe_move_args_size_note (last2_sp_set, last_sp_set, false);
575 maybe_move_args_size_note (insn, last_sp_set, true);
576 delete_insn (last_sp_set);
577 free_csa_reflist (reflist);
579 last_sp_set = NULL_RTX;
586 data.reflist = reflist;
587 if (!CALL_P (insn) && last_sp_set
588 && !for_each_rtx (&PATTERN (insn), record_stack_refs, &data))
590 reflist = data.reflist;
593 reflist = data.reflist;
595 /* Otherwise, we were not able to process the instruction.
596 Do not continue collecting data across such a one. */
599 || reg_mentioned_p (stack_pointer_rtx, PATTERN (insn))))
601 if (last_sp_set && last_sp_adjust == 0)
603 force_move_args_size_note (bb, last2_sp_set, last_sp_set);
604 delete_insn (last_sp_set);
606 free_csa_reflist (reflist);
608 last2_sp_set = NULL_RTX;
609 last_sp_set = NULL_RTX;
614 if (last_sp_set && last_sp_adjust == 0)
616 force_move_args_size_note (bb, last2_sp_set, last_sp_set);
617 delete_insn (last_sp_set);
621 free_csa_reflist (reflist);
626 gate_handle_stack_adjustments (void)
628 return flag_combine_stack_adjustments;
632 rest_of_handle_stack_adjustments (void)
634 cleanup_cfg (flag_crossjumping ? CLEANUP_CROSSJUMP : 0);
636 /* This is kind of a heuristic. We need to run combine_stack_adjustments
637 even for machines with possibly nonzero TARGET_RETURN_POPS_ARGS
638 and ACCUMULATE_OUTGOING_ARGS. We expect that only ports having
639 push instructions will have popping returns. */
640 #ifndef PUSH_ROUNDING
641 if (!ACCUMULATE_OUTGOING_ARGS)
644 df_note_add_problem ();
646 combine_stack_adjustments ();
651 struct rtl_opt_pass pass_stack_adjustments =
656 gate_handle_stack_adjustments, /* gate */
657 rest_of_handle_stack_adjustments, /* execute */
660 0, /* static_pass_number */
661 TV_COMBINE_STACK_ADJUST, /* tv_id */
662 0, /* properties_required */
663 0, /* properties_provided */
664 0, /* properties_destroyed */
665 0, /* todo_flags_start */
666 TODO_df_finish | TODO_verify_rtl_sharing |
667 TODO_ggc_collect, /* todo_flags_finish */