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, 2012 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
418 /* TODO: Find another way to indicate to the dwarf2 code that we
419 have not in fact lost an adjustment. */
420 test
= emit_insn_before (gen_rtx_CLOBBER (VOIDmode
, const0_rtx
), insn
);
422 add_reg_note (test
, REG_ARGS_SIZE
, XEXP (note
, 0));
425 /* Subroutine of combine_stack_adjustments, called for each basic block. */
428 combine_stack_adjustments_for_block (basic_block bb
)
430 HOST_WIDE_INT last_sp_adjust
= 0;
431 rtx last_sp_set
= NULL_RTX
;
432 rtx last2_sp_set
= NULL_RTX
;
433 struct csa_reflist
*reflist
= NULL
;
435 struct record_stack_refs_data data
;
436 bool end_of_block
= false;
438 for (insn
= BB_HEAD (bb
); !end_of_block
; insn
= next
)
440 end_of_block
= insn
== BB_END (bb
);
441 next
= NEXT_INSN (insn
);
446 set
= single_set_for_csa (insn
);
449 rtx dest
= SET_DEST (set
);
450 rtx src
= SET_SRC (set
);
452 /* Find constant additions to the stack pointer. */
453 if (dest
== stack_pointer_rtx
454 && GET_CODE (src
) == PLUS
455 && XEXP (src
, 0) == stack_pointer_rtx
456 && CONST_INT_P (XEXP (src
, 1)))
458 HOST_WIDE_INT this_adjust
= INTVAL (XEXP (src
, 1));
460 /* If we've not seen an adjustment previously, record
461 it now and continue. */
465 last_sp_adjust
= this_adjust
;
469 /* If not all recorded refs can be adjusted, or the
470 adjustment is now too large for a constant addition,
471 we cannot merge the two stack adjustments.
473 Also we need to be careful to not move stack pointer
474 such that we create stack accesses outside the allocated
475 area. We can combine an allocation into the first insn,
476 or a deallocation into the second insn. We can not
477 combine an allocation followed by a deallocation.
479 The only somewhat frequent occurrence of the later is when
480 a function allocates a stack frame but does not use it.
481 For this case, we would need to analyze rtl stream to be
482 sure that allocated area is really unused. This means not
483 only checking the memory references, but also all registers
484 or global memory references possibly containing a stack
487 Perhaps the best way to address this problem is to teach
488 gcc not to allocate stack for objects never used. */
490 /* Combine an allocation into the first instruction. */
491 if (STACK_GROWS_DOWNWARD
? this_adjust
<= 0 : this_adjust
>= 0)
493 if (try_apply_stack_adjustment (last_sp_set
, reflist
,
494 last_sp_adjust
+ this_adjust
,
498 maybe_move_args_size_note (last_sp_set
, insn
, false);
500 last_sp_adjust
+= this_adjust
;
505 /* Otherwise we have a deallocation. Do not combine with
506 a previous allocation. Combine into the second insn. */
507 else if (STACK_GROWS_DOWNWARD
508 ? last_sp_adjust
>= 0 : last_sp_adjust
<= 0)
510 if (try_apply_stack_adjustment (insn
, reflist
,
511 last_sp_adjust
+ this_adjust
,
515 maybe_move_args_size_note (insn
, last_sp_set
, true);
516 delete_insn (last_sp_set
);
518 last_sp_adjust
+= this_adjust
;
519 free_csa_reflist (reflist
);
525 /* Combination failed. Restart processing from here. If
526 deallocation+allocation conspired to cancel, we can
527 delete the old deallocation insn. */
530 if (last_sp_adjust
== 0)
532 maybe_move_args_size_note (insn
, last_sp_set
, true);
533 delete_insn (last_sp_set
);
536 last2_sp_set
= last_sp_set
;
538 free_csa_reflist (reflist
);
541 last_sp_adjust
= this_adjust
;
545 /* Find a store with pre-(dec|inc)rement or pre-modify of exactly
546 the previous adjustment and turn it into a simple store. This
547 is equivalent to anticipating the stack adjustment so this must
550 && ((STACK_GROWS_DOWNWARD
551 ? (GET_CODE (XEXP (dest
, 0)) == PRE_DEC
553 == (HOST_WIDE_INT
) GET_MODE_SIZE (GET_MODE (dest
)))
554 : (GET_CODE (XEXP (dest
, 0)) == PRE_INC
556 == -(HOST_WIDE_INT
) GET_MODE_SIZE (GET_MODE (dest
))))
557 || ((STACK_GROWS_DOWNWARD
558 ? last_sp_adjust
>= 0 : last_sp_adjust
<= 0)
559 && GET_CODE (XEXP (dest
, 0)) == PRE_MODIFY
560 && GET_CODE (XEXP (XEXP (dest
, 0), 1)) == PLUS
561 && XEXP (XEXP (XEXP (dest
, 0), 1), 0)
563 && GET_CODE (XEXP (XEXP (XEXP (dest
, 0), 1), 1))
565 && INTVAL (XEXP (XEXP (XEXP (dest
, 0), 1), 1))
567 && XEXP (XEXP (dest
, 0), 0) == stack_pointer_rtx
568 && !reg_mentioned_p (stack_pointer_rtx
, src
)
569 && memory_address_p (GET_MODE (dest
), stack_pointer_rtx
)
570 && try_apply_stack_adjustment (insn
, reflist
, 0,
574 maybe_move_args_size_note (last2_sp_set
, last_sp_set
, false);
576 maybe_move_args_size_note (insn
, last_sp_set
, true);
577 delete_insn (last_sp_set
);
578 free_csa_reflist (reflist
);
580 last_sp_set
= NULL_RTX
;
587 data
.reflist
= reflist
;
588 if (!CALL_P (insn
) && last_sp_set
589 && !for_each_rtx (&PATTERN (insn
), record_stack_refs
, &data
))
591 reflist
= data
.reflist
;
594 reflist
= data
.reflist
;
596 /* Otherwise, we were not able to process the instruction.
597 Do not continue collecting data across such a one. */
600 || reg_mentioned_p (stack_pointer_rtx
, PATTERN (insn
))))
602 if (last_sp_set
&& last_sp_adjust
== 0)
604 force_move_args_size_note (bb
, last2_sp_set
, last_sp_set
);
605 delete_insn (last_sp_set
);
607 free_csa_reflist (reflist
);
609 last2_sp_set
= NULL_RTX
;
610 last_sp_set
= NULL_RTX
;
615 if (last_sp_set
&& last_sp_adjust
== 0)
617 force_move_args_size_note (bb
, last2_sp_set
, last_sp_set
);
618 delete_insn (last_sp_set
);
622 free_csa_reflist (reflist
);
627 gate_handle_stack_adjustments (void)
629 return flag_combine_stack_adjustments
;
633 rest_of_handle_stack_adjustments (void)
635 cleanup_cfg (flag_crossjumping
? CLEANUP_CROSSJUMP
: 0);
637 /* This is kind of a heuristic. We need to run combine_stack_adjustments
638 even for machines with possibly nonzero TARGET_RETURN_POPS_ARGS
639 and ACCUMULATE_OUTGOING_ARGS. We expect that only ports having
640 push instructions will have popping returns. */
641 #ifndef PUSH_ROUNDING
642 if (!ACCUMULATE_OUTGOING_ARGS
)
645 df_note_add_problem ();
647 combine_stack_adjustments ();
652 struct rtl_opt_pass pass_stack_adjustments
=
657 gate_handle_stack_adjustments
, /* gate */
658 rest_of_handle_stack_adjustments
, /* execute */
661 0, /* static_pass_number */
662 TV_COMBINE_STACK_ADJUST
, /* tv_id */
663 0, /* properties_required */
664 0, /* properties_provided */
665 0, /* properties_destroyed */
666 0, /* todo_flags_start */
667 TODO_df_finish
| TODO_verify_rtl_sharing
|
668 TODO_ggc_collect
, /* todo_flags_finish */