1 /* Shrink-wrapping related optimizations.
2 Copyright (C) 1987-2014 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* This file handles shrink-wrapping related optimizations. */
24 #include "coretypes.h"
26 #include "rtl-error.h"
28 #include "stor-layout.h"
30 #include "stringpool.h"
38 #include "hard-reg-set.h"
39 #include "insn-config.h"
44 #include "langhooks.h"
46 #include "common/common-target.h"
47 #include "gimple-expr.h"
49 #include "tree-pass.h"
53 #include "bb-reorder.h"
54 #include "shrink-wrap.h"
57 #ifdef HAVE_simple_return
59 /* Return true if INSN requires the stack frame to be set up.
60 PROLOGUE_USED contains the hard registers used in the function
61 prologue. SET_UP_BY_PROLOGUE is the set of registers we expect the
62 prologue to set up for the function. */
64 requires_stack_frame_p (rtx insn
, HARD_REG_SET prologue_used
,
65 HARD_REG_SET set_up_by_prologue
)
68 HARD_REG_SET hardregs
;
72 return !SIBLING_CALL_P (insn
);
74 /* We need a frame to get the unique CFA expected by the unwinder. */
75 if (cfun
->can_throw_non_call_exceptions
&& can_throw_internal (insn
))
78 CLEAR_HARD_REG_SET (hardregs
);
79 for (df_rec
= DF_INSN_DEFS (insn
); *df_rec
; df_rec
++)
81 rtx dreg
= DF_REF_REG (*df_rec
);
86 add_to_hard_reg_set (&hardregs
, GET_MODE (dreg
),
89 if (hard_reg_set_intersect_p (hardregs
, prologue_used
))
91 AND_COMPL_HARD_REG_SET (hardregs
, call_used_reg_set
);
92 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
93 if (TEST_HARD_REG_BIT (hardregs
, regno
)
94 && df_regs_ever_live_p (regno
))
97 for (df_rec
= DF_INSN_USES (insn
); *df_rec
; df_rec
++)
99 rtx reg
= DF_REF_REG (*df_rec
);
104 add_to_hard_reg_set (&hardregs
, GET_MODE (reg
),
107 if (hard_reg_set_intersect_p (hardregs
, set_up_by_prologue
))
113 /* See whether there has a single live edge from BB, which dest uses
114 [REGNO, END_REGNO). Return the live edge if its dest bb has
115 one or two predecessors. Otherwise return NULL. */
118 live_edge_for_reg (basic_block bb
, int regno
, int end_regno
)
126 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
128 live
= df_get_live_in (e
->dest
);
129 for (i
= regno
; i
< end_regno
; i
++)
130 if (REGNO_REG_SET_P (live
, i
))
132 if (live_edge
&& live_edge
!= e
)
138 /* We can sometimes encounter dead code. Don't try to move it
139 into the exit block. */
140 if (!live_edge
|| live_edge
->dest
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
143 /* Reject targets of abnormal edges. This is needed for correctness
144 on ports like Alpha and MIPS, whose pic_offset_table_rtx can die on
145 exception edges even though it is generally treated as call-saved
146 for the majority of the compilation. Moving across abnormal edges
147 isn't going to be interesting for shrink-wrap usage anyway. */
148 if (live_edge
->flags
& EDGE_ABNORMAL
)
151 /* When live_edge->dest->preds == 2, we can create a new block on
152 the edge to make it meet the requirement. */
153 if (EDGE_COUNT (live_edge
->dest
->preds
) > 2)
159 /* Try to move INSN from BB to a successor. Return true on success.
160 USES and DEFS are the set of registers that are used and defined
161 after INSN in BB. SPLIT_P indicates whether a live edge from BB
162 is splitted or not. */
165 move_insn_for_shrink_wrap (basic_block bb
, rtx insn
,
166 const HARD_REG_SET uses
,
167 const HARD_REG_SET defs
,
171 bitmap live_out
, live_in
, bb_uses
, bb_defs
;
172 unsigned int i
, dregno
, end_dregno
, sregno
, end_sregno
;
173 basic_block next_block
;
176 /* Look for a simple register copy. */
177 set
= single_set (insn
);
181 dest
= SET_DEST (set
);
182 if (!REG_P (dest
) || !REG_P (src
)
183 /* STACK or FRAME related adjustment might be part of prologue.
184 So keep them in the entry block. */
185 || dest
== stack_pointer_rtx
186 || dest
== frame_pointer_rtx
187 || dest
== hard_frame_pointer_rtx
)
190 /* Make sure that the source register isn't defined later in BB. */
191 sregno
= REGNO (src
);
192 end_sregno
= END_REGNO (src
);
193 if (overlaps_hard_reg_set_p (defs
, GET_MODE (src
), sregno
))
196 /* Make sure that the destination register isn't referenced later in BB. */
197 dregno
= REGNO (dest
);
198 end_dregno
= END_REGNO (dest
);
199 if (overlaps_hard_reg_set_p (uses
, GET_MODE (dest
), dregno
)
200 || overlaps_hard_reg_set_p (defs
, GET_MODE (dest
), dregno
))
203 /* See whether there is a successor block to which we could move INSN. */
204 live_edge
= live_edge_for_reg (bb
, dregno
, end_dregno
);
208 next_block
= live_edge
->dest
;
209 /* Create a new basic block on the edge. */
210 if (EDGE_COUNT (next_block
->preds
) == 2)
212 /* split_edge for a block with only one successor is meaningless. */
213 if (EDGE_COUNT (bb
->succs
) == 1)
216 next_block
= split_edge (live_edge
);
218 bitmap_copy (df_get_live_in (next_block
), df_get_live_out (bb
));
219 df_set_bb_dirty (next_block
);
221 /* We should not split more than once for a function. */
222 gcc_assert (!(*split_p
));
226 /* At this point we are committed to moving INSN, but let's try to
227 move it as far as we can. */
230 live_out
= df_get_live_out (bb
);
231 live_in
= df_get_live_in (next_block
);
234 /* Check whether BB uses DEST or clobbers DEST. We need to add
235 INSN to BB if so. Either way, DEST is no longer live on entry,
236 except for any part that overlaps SRC (next loop). */
237 bb_uses
= &DF_LR_BB_INFO (bb
)->use
;
238 bb_defs
= &DF_LR_BB_INFO (bb
)->def
;
241 for (i
= dregno
; i
< end_dregno
; i
++)
244 || REGNO_REG_SET_P (bb_uses
, i
)
245 || REGNO_REG_SET_P (bb_defs
, i
)
246 || REGNO_REG_SET_P (&DF_LIVE_BB_INFO (bb
)->gen
, i
))
248 CLEAR_REGNO_REG_SET (live_out
, i
);
249 CLEAR_REGNO_REG_SET (live_in
, i
);
252 /* Check whether BB clobbers SRC. We need to add INSN to BB if so.
253 Either way, SRC is now live on entry. */
254 for (i
= sregno
; i
< end_sregno
; i
++)
257 || REGNO_REG_SET_P (bb_defs
, i
)
258 || REGNO_REG_SET_P (&DF_LIVE_BB_INFO (bb
)->gen
, i
))
260 SET_REGNO_REG_SET (live_out
, i
);
261 SET_REGNO_REG_SET (live_in
, i
);
266 /* DF_LR_BB_INFO (bb)->def does not comprise the DF_REF_PARTIAL and
267 DF_REF_CONDITIONAL defs. So if DF_LIVE doesn't exist, i.e.
268 at -O1, just give up searching NEXT_BLOCK. */
270 for (i
= dregno
; i
< end_dregno
; i
++)
272 CLEAR_REGNO_REG_SET (live_out
, i
);
273 CLEAR_REGNO_REG_SET (live_in
, i
);
276 for (i
= sregno
; i
< end_sregno
; i
++)
278 SET_REGNO_REG_SET (live_out
, i
);
279 SET_REGNO_REG_SET (live_in
, i
);
283 /* If we don't need to add the move to BB, look for a single
287 live_edge
= live_edge_for_reg (next_block
, dregno
, end_dregno
);
288 if (!live_edge
|| EDGE_COUNT (live_edge
->dest
->preds
) > 1)
290 next_block
= live_edge
->dest
;
295 /* For the new created basic block, there is no dataflow info at all.
296 So skip the following dataflow update and check. */
299 /* BB now defines DEST. It only uses the parts of DEST that overlap SRC
301 for (i
= dregno
; i
< end_dregno
; i
++)
303 CLEAR_REGNO_REG_SET (bb_uses
, i
);
304 SET_REGNO_REG_SET (bb_defs
, i
);
307 /* BB now uses SRC. */
308 for (i
= sregno
; i
< end_sregno
; i
++)
309 SET_REGNO_REG_SET (bb_uses
, i
);
312 emit_insn_after (PATTERN (insn
), bb_note (bb
));
317 /* Look for register copies in the first block of the function, and move
318 them down into successor blocks if the register is used only on one
319 path. This exposes more opportunities for shrink-wrapping. These
320 kinds of sets often occur when incoming argument registers are moved
321 to call-saved registers because their values are live across one or
322 more calls during the function. */
325 prepare_shrink_wrap (basic_block entry_block
)
328 HARD_REG_SET uses
, defs
;
330 bool split_p
= false;
332 if (JUMP_P (BB_END (entry_block
)))
334 /* To have more shrink-wrapping opportunities, prepare_shrink_wrap tries
335 to sink the copies from parameter to callee saved register out of
336 entry block. copyprop_hardreg_forward_bb_without_debug_insn is called
337 to release some dependences. */
338 copyprop_hardreg_forward_bb_without_debug_insn (entry_block
);
341 CLEAR_HARD_REG_SET (uses
);
342 CLEAR_HARD_REG_SET (defs
);
343 FOR_BB_INSNS_REVERSE_SAFE (entry_block
, insn
, curr
)
344 if (NONDEBUG_INSN_P (insn
)
345 && !move_insn_for_shrink_wrap (entry_block
, insn
, uses
, defs
,
348 /* Add all defined registers to DEFs. */
349 for (ref
= DF_INSN_DEFS (insn
); *ref
; ref
++)
351 x
= DF_REF_REG (*ref
);
352 if (REG_P (x
) && HARD_REGISTER_P (x
))
353 SET_HARD_REG_BIT (defs
, REGNO (x
));
356 /* Add all used registers to USESs. */
357 for (ref
= DF_INSN_USES (insn
); *ref
; ref
++)
359 x
= DF_REF_REG (*ref
);
360 if (REG_P (x
) && HARD_REGISTER_P (x
))
361 SET_HARD_REG_BIT (uses
, REGNO (x
));
366 /* Create a copy of BB instructions and insert at BEFORE. Redirect
367 preds of BB to COPY_BB if they don't appear in NEED_PROLOGUE. */
369 dup_block_and_redirect (basic_block bb
, basic_block copy_bb
, rtx before
,
370 bitmap_head
*need_prologue
)
374 rtx insn
= BB_END (bb
);
376 /* We know BB has a single successor, so there is no need to copy a
377 simple jump at the end of BB. */
378 if (simplejump_p (insn
))
379 insn
= PREV_INSN (insn
);
382 duplicate_insn_chain (BB_HEAD (bb
), insn
);
386 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
387 if (active_insn_p (insn
))
389 fprintf (dump_file
, "Duplicating bb %d to bb %d, %u active insns.\n",
390 bb
->index
, copy_bb
->index
, count
);
394 emit_insn_before (insn
, before
);
396 /* Redirect all the paths that need no prologue into copy_bb. */
397 for (ei
= ei_start (bb
->preds
); (e
= ei_safe_edge (ei
));)
398 if (!bitmap_bit_p (need_prologue
, e
->src
->index
))
400 int freq
= EDGE_FREQUENCY (e
);
401 copy_bb
->count
+= e
->count
;
402 copy_bb
->frequency
+= EDGE_FREQUENCY (e
);
403 e
->dest
->count
-= e
->count
;
404 if (e
->dest
->count
< 0)
406 e
->dest
->frequency
-= freq
;
407 if (e
->dest
->frequency
< 0)
408 e
->dest
->frequency
= 0;
409 redirect_edge_and_branch_force (e
, copy_bb
);
417 /* Try to perform a kind of shrink-wrapping, making sure the
418 prologue/epilogue is emitted only around those parts of the
419 function that require it. */
422 try_shrink_wrapping (edge
*entry_edge
, edge orig_entry_edge
,
423 bitmap_head
*bb_flags
, rtx prologue_seq
)
427 bool nonempty_prologue
= false;
428 unsigned max_grow_size
;
431 for (seq
= prologue_seq
; seq
; seq
= NEXT_INSN (seq
))
432 if (!NOTE_P (seq
) || NOTE_KIND (seq
) != NOTE_INSN_PROLOGUE_END
)
434 nonempty_prologue
= true;
438 if (flag_shrink_wrap
&& HAVE_simple_return
439 && (targetm
.profile_before_prologue () || !crtl
->profile
)
440 && nonempty_prologue
&& !crtl
->calls_eh_return
)
442 HARD_REG_SET prologue_clobbered
, prologue_used
, live_on_edge
;
443 struct hard_reg_set_container set_up_by_prologue
;
445 vec
<basic_block
> vec
;
447 bitmap_head bb_antic_flags
;
448 bitmap_head bb_on_list
;
452 fprintf (dump_file
, "Attempting shrink-wrapping optimization.\n");
454 /* Compute the registers set and used in the prologue. */
455 CLEAR_HARD_REG_SET (prologue_clobbered
);
456 CLEAR_HARD_REG_SET (prologue_used
);
457 for (p_insn
= prologue_seq
; p_insn
; p_insn
= NEXT_INSN (p_insn
))
459 HARD_REG_SET this_used
;
460 if (!NONDEBUG_INSN_P (p_insn
))
463 CLEAR_HARD_REG_SET (this_used
);
464 note_uses (&PATTERN (p_insn
), record_hard_reg_uses
,
466 AND_COMPL_HARD_REG_SET (this_used
, prologue_clobbered
);
467 IOR_HARD_REG_SET (prologue_used
, this_used
);
468 note_stores (PATTERN (p_insn
), record_hard_reg_sets
,
469 &prologue_clobbered
);
472 prepare_shrink_wrap ((*entry_edge
)->dest
);
474 bitmap_initialize (&bb_antic_flags
, &bitmap_default_obstack
);
475 bitmap_initialize (&bb_on_list
, &bitmap_default_obstack
);
476 bitmap_initialize (&bb_tail
, &bitmap_default_obstack
);
478 /* Find the set of basic blocks that require a stack frame,
479 and blocks that are too big to be duplicated. */
481 vec
.create (n_basic_blocks_for_fn (cfun
));
483 CLEAR_HARD_REG_SET (set_up_by_prologue
.set
);
484 add_to_hard_reg_set (&set_up_by_prologue
.set
, Pmode
,
485 STACK_POINTER_REGNUM
);
486 add_to_hard_reg_set (&set_up_by_prologue
.set
, Pmode
, ARG_POINTER_REGNUM
);
487 if (frame_pointer_needed
)
488 add_to_hard_reg_set (&set_up_by_prologue
.set
, Pmode
,
489 HARD_FRAME_POINTER_REGNUM
);
490 if (pic_offset_table_rtx
)
491 add_to_hard_reg_set (&set_up_by_prologue
.set
, Pmode
,
492 PIC_OFFSET_TABLE_REGNUM
);
494 add_to_hard_reg_set (&set_up_by_prologue
.set
,
495 GET_MODE (crtl
->drap_reg
),
496 REGNO (crtl
->drap_reg
));
497 if (targetm
.set_up_by_prologue
)
498 targetm
.set_up_by_prologue (&set_up_by_prologue
);
500 /* We don't use a different max size depending on
501 optimize_bb_for_speed_p because increasing shrink-wrapping
502 opportunities by duplicating tail blocks can actually result
503 in an overall decrease in code size. */
504 max_grow_size
= get_uncond_jump_length ();
505 max_grow_size
*= PARAM_VALUE (PARAM_MAX_GROW_COPY_BB_INSNS
);
507 FOR_EACH_BB_FN (bb
, cfun
)
512 FOR_BB_INSNS (bb
, insn
)
513 if (NONDEBUG_INSN_P (insn
))
515 if (requires_stack_frame_p (insn
, prologue_used
,
516 set_up_by_prologue
.set
))
518 if (bb
== (*entry_edge
)->dest
)
519 goto fail_shrinkwrap
;
520 bitmap_set_bit (bb_flags
, bb
->index
);
524 else if (size
<= max_grow_size
)
526 size
+= get_attr_min_length (insn
);
527 if (size
> max_grow_size
)
528 bitmap_set_bit (&bb_on_list
, bb
->index
);
533 /* Blocks that really need a prologue, or are too big for tails. */
534 bitmap_ior_into (&bb_on_list
, bb_flags
);
536 /* For every basic block that needs a prologue, mark all blocks
537 reachable from it, so as to ensure they are also seen as
538 requiring a prologue. */
539 while (!vec
.is_empty ())
541 basic_block tmp_bb
= vec
.pop ();
543 FOR_EACH_EDGE (e
, ei
, tmp_bb
->succs
)
544 if (e
->dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
)
545 && bitmap_set_bit (bb_flags
, e
->dest
->index
))
546 vec
.quick_push (e
->dest
);
549 /* Find the set of basic blocks that need no prologue, have a
550 single successor, can be duplicated, meet a max size
551 requirement, and go to the exit via like blocks. */
552 vec
.quick_push (EXIT_BLOCK_PTR_FOR_FN (cfun
));
553 while (!vec
.is_empty ())
555 basic_block tmp_bb
= vec
.pop ();
557 FOR_EACH_EDGE (e
, ei
, tmp_bb
->preds
)
558 if (single_succ_p (e
->src
)
559 && !bitmap_bit_p (&bb_on_list
, e
->src
->index
)
560 && can_duplicate_block_p (e
->src
))
565 /* If there is predecessor of e->src which doesn't
566 need prologue and the edge is complex,
567 we might not be able to redirect the branch
568 to a copy of e->src. */
569 FOR_EACH_EDGE (pe
, pei
, e
->src
->preds
)
570 if ((pe
->flags
& EDGE_COMPLEX
) != 0
571 && !bitmap_bit_p (bb_flags
, pe
->src
->index
))
573 if (pe
== NULL
&& bitmap_set_bit (&bb_tail
, e
->src
->index
))
574 vec
.quick_push (e
->src
);
578 /* Now walk backwards from every block that is marked as needing
579 a prologue to compute the bb_antic_flags bitmap. Exclude
580 tail blocks; They can be duplicated to be used on paths not
581 needing a prologue. */
582 bitmap_clear (&bb_on_list
);
583 bitmap_and_compl (&bb_antic_flags
, bb_flags
, &bb_tail
);
584 FOR_EACH_BB_FN (bb
, cfun
)
586 if (!bitmap_bit_p (&bb_antic_flags
, bb
->index
))
588 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
589 if (!bitmap_bit_p (&bb_antic_flags
, e
->src
->index
)
590 && bitmap_set_bit (&bb_on_list
, e
->src
->index
))
591 vec
.quick_push (e
->src
);
593 while (!vec
.is_empty ())
595 basic_block tmp_bb
= vec
.pop ();
598 bitmap_clear_bit (&bb_on_list
, tmp_bb
->index
);
599 FOR_EACH_EDGE (e
, ei
, tmp_bb
->succs
)
600 if (!bitmap_bit_p (&bb_antic_flags
, e
->dest
->index
))
608 bitmap_set_bit (&bb_antic_flags
, tmp_bb
->index
);
609 FOR_EACH_EDGE (e
, ei
, tmp_bb
->preds
)
610 if (!bitmap_bit_p (&bb_antic_flags
, e
->src
->index
)
611 && bitmap_set_bit (&bb_on_list
, e
->src
->index
))
612 vec
.quick_push (e
->src
);
615 /* Find exactly one edge that leads to a block in ANTIC from
616 a block that isn't. */
617 if (!bitmap_bit_p (&bb_antic_flags
, (*entry_edge
)->dest
->index
))
618 FOR_EACH_BB_FN (bb
, cfun
)
620 if (!bitmap_bit_p (&bb_antic_flags
, bb
->index
))
622 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
623 if (!bitmap_bit_p (&bb_antic_flags
, e
->src
->index
))
625 if (*entry_edge
!= orig_entry_edge
)
627 *entry_edge
= orig_entry_edge
;
629 fprintf (dump_file
, "More than one candidate edge.\n");
630 goto fail_shrinkwrap
;
633 fprintf (dump_file
, "Found candidate edge for "
634 "shrink-wrapping, %d->%d.\n", e
->src
->index
,
640 if (*entry_edge
!= orig_entry_edge
)
642 /* Test whether the prologue is known to clobber any register
643 (other than FP or SP) which are live on the edge. */
644 CLEAR_HARD_REG_BIT (prologue_clobbered
, STACK_POINTER_REGNUM
);
645 if (frame_pointer_needed
)
646 CLEAR_HARD_REG_BIT (prologue_clobbered
, HARD_FRAME_POINTER_REGNUM
);
647 REG_SET_TO_HARD_REG_SET (live_on_edge
,
648 df_get_live_in ((*entry_edge
)->dest
));
649 if (hard_reg_set_intersect_p (live_on_edge
, prologue_clobbered
))
651 *entry_edge
= orig_entry_edge
;
654 "Shrink-wrapping aborted due to clobber.\n");
657 if (*entry_edge
!= orig_entry_edge
)
659 crtl
->shrink_wrapped
= true;
661 fprintf (dump_file
, "Performing shrink-wrapping.\n");
663 /* Find tail blocks reachable from both blocks needing a
664 prologue and blocks not needing a prologue. */
665 if (!bitmap_empty_p (&bb_tail
))
666 FOR_EACH_BB_FN (bb
, cfun
)
668 bool some_pro
, some_no_pro
;
669 if (!bitmap_bit_p (&bb_tail
, bb
->index
))
671 some_pro
= some_no_pro
= false;
672 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
674 if (bitmap_bit_p (bb_flags
, e
->src
->index
))
679 if (some_pro
&& some_no_pro
)
682 bitmap_clear_bit (&bb_tail
, bb
->index
);
684 /* Find the head of each tail. */
685 while (!vec
.is_empty ())
687 basic_block tbb
= vec
.pop ();
689 if (!bitmap_bit_p (&bb_tail
, tbb
->index
))
692 while (single_succ_p (tbb
))
694 tbb
= single_succ (tbb
);
695 bitmap_clear_bit (&bb_tail
, tbb
->index
);
698 /* Now duplicate the tails. */
699 if (!bitmap_empty_p (&bb_tail
))
700 FOR_EACH_BB_REVERSE_FN (bb
, cfun
)
702 basic_block copy_bb
, tbb
;
706 if (!bitmap_clear_bit (&bb_tail
, bb
->index
))
709 /* Create a copy of BB, instructions and all, for
710 use on paths that don't need a prologue.
711 Ideal placement of the copy is on a fall-thru edge
712 or after a block that would jump to the copy. */
713 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
714 if (!bitmap_bit_p (bb_flags
, e
->src
->index
)
715 && single_succ_p (e
->src
))
719 /* Make sure we insert after any barriers. */
720 rtx end
= get_last_bb_insn (e
->src
);
721 copy_bb
= create_basic_block (NEXT_INSN (end
),
723 BB_COPY_PARTITION (copy_bb
, e
->src
);
727 /* Otherwise put the copy at the end of the function. */
728 copy_bb
= create_basic_block (NULL_RTX
, NULL_RTX
,
729 EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
);
730 BB_COPY_PARTITION (copy_bb
, bb
);
733 insert_point
= emit_note_after (NOTE_INSN_DELETED
,
735 emit_barrier_after (BB_END (copy_bb
));
740 dup_block_and_redirect (tbb
, copy_bb
, insert_point
,
742 tbb
= single_succ (tbb
);
743 if (tbb
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
745 e
= split_block (copy_bb
, PREV_INSN (insert_point
));
749 /* Quiet verify_flow_info by (ab)using EDGE_FAKE.
750 We have yet to add a simple_return to the tails,
751 as we'd like to first convert_jumps_to_returns in
752 case the block is no longer used after that. */
754 if (CALL_P (PREV_INSN (insert_point
))
755 && SIBLING_CALL_P (PREV_INSN (insert_point
)))
756 eflags
= EDGE_SIBCALL
| EDGE_ABNORMAL
;
757 make_single_succ_edge (copy_bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
),
760 /* verify_flow_info doesn't like a note after a
762 delete_insn (insert_point
);
763 if (bitmap_empty_p (&bb_tail
))
769 bitmap_clear (&bb_tail
);
770 bitmap_clear (&bb_antic_flags
);
771 bitmap_clear (&bb_on_list
);
776 /* If we're allowed to generate a simple return instruction, then by
777 definition we don't need a full epilogue. If the last basic
778 block before the exit block does not contain active instructions,
779 examine its predecessors and try to emit (conditional) return
783 get_unconverted_simple_return (edge exit_fallthru_edge
, bitmap_head bb_flags
,
784 vec
<edge
> *unconverted_simple_returns
,
791 /* convert_jumps_to_returns may add to preds of the exit block
792 (but won't remove). Stop at end of current preds. */
793 last
= EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
);
794 for (i
= 0; i
< last
; i
++)
796 edge e
= EDGE_I (EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
, i
);
797 if (LABEL_P (BB_HEAD (e
->src
))
798 && !bitmap_bit_p (&bb_flags
, e
->src
->index
)
799 && !active_insn_between (BB_HEAD (e
->src
), BB_END (e
->src
)))
800 *unconverted_simple_returns
801 = convert_jumps_to_returns (e
->src
, true,
802 *unconverted_simple_returns
);
806 if (exit_fallthru_edge
!= NULL
807 && EDGE_COUNT (exit_fallthru_edge
->src
->preds
) != 0
808 && !bitmap_bit_p (&bb_flags
, exit_fallthru_edge
->src
->index
))
812 last_bb
= emit_return_for_exit (exit_fallthru_edge
, true);
813 *returnjump
= BB_END (last_bb
);
814 exit_fallthru_edge
= NULL
;
816 return exit_fallthru_edge
;
819 /* If there were branches to an empty LAST_BB which we tried to
820 convert to conditional simple_returns, but couldn't for some
821 reason, create a block to hold a simple_return insn and redirect
822 those remaining edges. */
825 convert_to_simple_return (edge entry_edge
, edge orig_entry_edge
,
826 bitmap_head bb_flags
, rtx returnjump
,
827 vec
<edge
> unconverted_simple_returns
)
832 if (!unconverted_simple_returns
.is_empty ())
834 basic_block simple_return_block_hot
= NULL
;
835 basic_block simple_return_block_cold
= NULL
;
836 edge pending_edge_hot
= NULL
;
837 edge pending_edge_cold
= NULL
;
838 basic_block exit_pred
;
841 gcc_assert (entry_edge
!= orig_entry_edge
);
843 /* See if we can reuse the last insn that was emitted for the
845 if (returnjump
!= NULL_RTX
846 && JUMP_LABEL (returnjump
) == simple_return_rtx
)
848 e
= split_block (BLOCK_FOR_INSN (returnjump
), PREV_INSN (returnjump
));
849 if (BB_PARTITION (e
->src
) == BB_HOT_PARTITION
)
850 simple_return_block_hot
= e
->dest
;
852 simple_return_block_cold
= e
->dest
;
855 /* Also check returns we might need to add to tail blocks. */
856 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
857 if (EDGE_COUNT (e
->src
->preds
) != 0
858 && (e
->flags
& EDGE_FAKE
) != 0
859 && !bitmap_bit_p (&bb_flags
, e
->src
->index
))
861 if (BB_PARTITION (e
->src
) == BB_HOT_PARTITION
)
862 pending_edge_hot
= e
;
864 pending_edge_cold
= e
;
867 /* Save a pointer to the exit's predecessor BB for use in
868 inserting new BBs at the end of the function. Do this
869 after the call to split_block above which may split
870 the original exit pred. */
871 exit_pred
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
;
873 FOR_EACH_VEC_ELT (unconverted_simple_returns
, i
, e
)
875 basic_block
*pdest_bb
;
878 if (BB_PARTITION (e
->src
) == BB_HOT_PARTITION
)
880 pdest_bb
= &simple_return_block_hot
;
881 pending
= pending_edge_hot
;
885 pdest_bb
= &simple_return_block_cold
;
886 pending
= pending_edge_cold
;
889 if (*pdest_bb
== NULL
&& pending
!= NULL
)
891 emit_return_into_block (true, pending
->src
);
892 pending
->flags
&= ~(EDGE_FALLTHRU
| EDGE_FAKE
);
893 *pdest_bb
= pending
->src
;
895 else if (*pdest_bb
== NULL
)
900 bb
= create_basic_block (NULL
, NULL
, exit_pred
);
901 BB_COPY_PARTITION (bb
, e
->src
);
902 start
= emit_jump_insn_after (gen_simple_return (),
904 JUMP_LABEL (start
) = simple_return_rtx
;
905 emit_barrier_after (start
);
908 make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
910 redirect_edge_and_branch_force (e
, *pdest_bb
);
912 unconverted_simple_returns
.release ();
915 if (entry_edge
!= orig_entry_edge
)
917 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
918 if (EDGE_COUNT (e
->src
->preds
) != 0
919 && (e
->flags
& EDGE_FAKE
) != 0
920 && !bitmap_bit_p (&bb_flags
, e
->src
->index
))
922 emit_return_into_block (true, e
->src
);
923 e
->flags
&= ~(EDGE_FALLTHRU
| EDGE_FAKE
);