1 /* Hooks for cfg representation specific functions.
2 Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
3 Contributed by Sebastian Pop <s.pop@laposte.net>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
24 #include "coretypes.h"
28 #include "basic-block.h"
29 #include "tree-flow.h"
34 /* A pointer to one of the hooks containers. */
35 static struct cfg_hooks
*cfg_hooks
;
37 /* Initialization of functions specific to the rtl IR. */
39 rtl_register_cfg_hooks (void)
41 cfg_hooks
= &rtl_cfg_hooks
;
44 /* Initialization of functions specific to the rtl IR. */
46 cfg_layout_rtl_register_cfg_hooks (void)
48 cfg_hooks
= &cfg_layout_rtl_cfg_hooks
;
51 /* Initialization of functions specific to the tree IR. */
54 tree_register_cfg_hooks (void)
56 cfg_hooks
= &tree_cfg_hooks
;
59 /* Returns current ir type. */
62 current_ir_type (void)
64 if (cfg_hooks
== &tree_cfg_hooks
)
66 else if (cfg_hooks
== &rtl_cfg_hooks
)
68 else if (cfg_hooks
== &cfg_layout_rtl_cfg_hooks
)
69 return IR_RTL_CFGLAYOUT
;
74 /* Verify the CFG consistency.
76 Currently it does following: checks edge and basic block list correctness
77 and calls into IL dependent checking then. */
80 verify_flow_info (void)
82 size_t *edge_checksum
;
84 basic_block bb
, last_bb_seen
;
85 basic_block
*last_visited
;
87 timevar_push (TV_CFG_VERIFY
);
88 last_visited
= XCNEWVEC (basic_block
, last_basic_block
);
89 edge_checksum
= XCNEWVEC (size_t, last_basic_block
);
91 /* Check bb chain & numbers. */
92 last_bb_seen
= ENTRY_BLOCK_PTR
;
93 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR
->next_bb
, NULL
, next_bb
)
95 if (bb
!= EXIT_BLOCK_PTR
96 && bb
!= BASIC_BLOCK (bb
->index
))
98 error ("bb %d on wrong place", bb
->index
);
102 if (bb
->prev_bb
!= last_bb_seen
)
104 error ("prev_bb of %d should be %d, not %d",
105 bb
->index
, last_bb_seen
->index
, bb
->prev_bb
->index
);
112 /* Now check the basic blocks (boundaries etc.) */
113 FOR_EACH_BB_REVERSE (bb
)
119 if (bb
->loop_father
!= NULL
&& current_loops
== NULL
)
121 error ("verify_flow_info: Block %i has loop_father, but there are no loops",
125 if (bb
->loop_father
== NULL
&& current_loops
!= NULL
)
127 error ("verify_flow_info: Block %i lacks loop_father", bb
->index
);
133 error ("verify_flow_info: Wrong count of block %i %i",
134 bb
->index
, (int)bb
->count
);
137 if (bb
->frequency
< 0)
139 error ("verify_flow_info: Wrong frequency of block %i %i",
140 bb
->index
, bb
->frequency
);
143 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
145 if (last_visited
[e
->dest
->index
] == bb
)
147 error ("verify_flow_info: Duplicate edge %i->%i",
148 e
->src
->index
, e
->dest
->index
);
151 if (e
->probability
< 0 || e
->probability
> REG_BR_PROB_BASE
)
153 error ("verify_flow_info: Wrong probability of edge %i->%i %i",
154 e
->src
->index
, e
->dest
->index
, e
->probability
);
159 error ("verify_flow_info: Wrong count of edge %i->%i %i",
160 e
->src
->index
, e
->dest
->index
, (int)e
->count
);
164 last_visited
[e
->dest
->index
] = bb
;
166 if (e
->flags
& EDGE_FALLTHRU
)
171 error ("verify_flow_info: Basic block %d succ edge is corrupted",
173 fprintf (stderr
, "Predecessor: ");
174 dump_edge_info (stderr
, e
, 0);
175 fprintf (stderr
, "\nSuccessor: ");
176 dump_edge_info (stderr
, e
, 1);
177 fprintf (stderr
, "\n");
181 edge_checksum
[e
->dest
->index
] += (size_t) e
;
185 error ("wrong amount of branch edges after unconditional jump %i", bb
->index
);
189 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
193 error ("basic block %d pred edge is corrupted", bb
->index
);
194 fputs ("Predecessor: ", stderr
);
195 dump_edge_info (stderr
, e
, 0);
196 fputs ("\nSuccessor: ", stderr
);
197 dump_edge_info (stderr
, e
, 1);
198 fputc ('\n', stderr
);
202 if (ei
.index
!= e
->dest_idx
)
204 error ("basic block %d pred edge is corrupted", bb
->index
);
205 error ("its dest_idx should be %d, not %d",
206 ei
.index
, e
->dest_idx
);
207 fputs ("Predecessor: ", stderr
);
208 dump_edge_info (stderr
, e
, 0);
209 fputs ("\nSuccessor: ", stderr
);
210 dump_edge_info (stderr
, e
, 1);
211 fputc ('\n', stderr
);
215 edge_checksum
[e
->dest
->index
] -= (size_t) e
;
219 /* Complete edge checksumming for ENTRY and EXIT. */
224 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR
->succs
)
225 edge_checksum
[e
->dest
->index
] += (size_t) e
;
227 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
228 edge_checksum
[e
->dest
->index
] -= (size_t) e
;
231 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR
, NULL
, next_bb
)
232 if (edge_checksum
[bb
->index
])
234 error ("basic block %i edge lists are corrupted", bb
->index
);
238 last_bb_seen
= ENTRY_BLOCK_PTR
;
242 free (edge_checksum
);
244 if (cfg_hooks
->verify_flow_info
)
245 err
|= cfg_hooks
->verify_flow_info ();
247 internal_error ("verify_flow_info failed");
248 timevar_pop (TV_CFG_VERIFY
);
251 /* Print out one basic block. This function takes care of the purely
252 graph related information. The cfg hook for the active representation
253 should dump representation-specific information. */
256 dump_bb (basic_block bb
, FILE *outf
, int indent
)
262 s_indent
= (char *) alloca ((size_t) indent
+ 1);
263 memset (s_indent
, ' ', (size_t) indent
);
264 s_indent
[indent
] = '\0';
266 fprintf (outf
, ";;%s basic block %d, loop depth %d, count ",
267 s_indent
, bb
->index
, bb
->loop_depth
);
268 fprintf (outf
, HOST_WIDEST_INT_PRINT_DEC
, (HOST_WIDEST_INT
) bb
->count
);
271 fprintf (outf
, ";;%s prev block ", s_indent
);
273 fprintf (outf
, "%d, ", bb
->prev_bb
->index
);
275 fprintf (outf
, "(nil), ");
276 fprintf (outf
, "next block ");
278 fprintf (outf
, "%d", bb
->next_bb
->index
);
280 fprintf (outf
, "(nil)");
283 fprintf (outf
, ";;%s pred: ", s_indent
);
284 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
285 dump_edge_info (outf
, e
, 0);
288 fprintf (outf
, ";;%s succ: ", s_indent
);
289 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
290 dump_edge_info (outf
, e
, 1);
293 if (cfg_hooks
->dump_bb
)
294 cfg_hooks
->dump_bb (bb
, outf
, indent
);
297 /* Redirect edge E to the given basic block DEST and update underlying program
298 representation. Returns edge representing redirected branch (that may not
299 be equivalent to E in the case of duplicate edges being removed) or NULL
300 if edge is not easily redirectable for whatever reason. */
303 redirect_edge_and_branch (edge e
, basic_block dest
)
307 if (!cfg_hooks
->redirect_edge_and_branch
)
308 internal_error ("%s does not support redirect_edge_and_branch",
311 ret
= cfg_hooks
->redirect_edge_and_branch (e
, dest
);
313 /* If RET != E, then the edge E was removed since RET already lead to the
315 if (ret
!= NULL
&& current_loops
!= NULL
)
316 rescan_loop_exit (e
, false, ret
!= e
);
321 /* Returns true if it is possible to remove the edge E by redirecting it
322 to the destination of the other edge going from its source. */
325 can_remove_branch_p (edge e
)
327 if (!cfg_hooks
->can_remove_branch_p
)
328 internal_error ("%s does not support can_remove_branch_p",
331 if (EDGE_COUNT (e
->src
->succs
) != 2)
334 return cfg_hooks
->can_remove_branch_p (e
);
337 /* Removes E, by redirecting it to the destination of the other edge going
338 from its source. Can_remove_branch_p must be true for E, hence this
339 operation cannot fail. */
342 remove_branch (edge e
)
345 basic_block src
= e
->src
;
348 gcc_assert (EDGE_COUNT (e
->src
->succs
) == 2);
350 other
= EDGE_SUCC (src
, EDGE_SUCC (src
, 0) == e
);
351 irr
= other
->flags
& EDGE_IRREDUCIBLE_LOOP
;
353 if (current_loops
!= NULL
)
354 rescan_loop_exit (e
, false, true);
356 e
= redirect_edge_and_branch (e
, other
->dest
);
357 gcc_assert (e
!= NULL
);
359 e
->flags
&= ~EDGE_IRREDUCIBLE_LOOP
;
363 /* Redirect the edge E to basic block DEST even if it requires creating
364 of a new basic block; then it returns the newly created basic block.
365 Aborts when redirection is impossible. */
368 redirect_edge_and_branch_force (edge e
, basic_block dest
)
370 basic_block ret
, src
= e
->src
;
373 if (!cfg_hooks
->redirect_edge_and_branch_force
)
374 internal_error ("%s does not support redirect_edge_and_branch_force",
377 if (current_loops
!= NULL
)
378 rescan_loop_exit (e
, false, true);
380 ret
= cfg_hooks
->redirect_edge_and_branch_force (e
, dest
);
382 && dom_info_available_p (CDI_DOMINATORS
))
383 set_immediate_dominator (CDI_DOMINATORS
, ret
, src
);
385 if (current_loops
!= NULL
)
389 loop
= find_common_loop (single_pred (ret
)->loop_father
,
390 single_succ (ret
)->loop_father
);
391 add_bb_to_loop (ret
, loop
);
393 else if (find_edge (src
, dest
) == e
)
394 rescan_loop_exit (e
, true, false);
400 /* Splits basic block BB after the specified instruction I (but at least after
401 the labels). If I is NULL, splits just after labels. The newly created edge
402 is returned. The new basic block is created just after the old one. */
405 split_block (basic_block bb
, void *i
)
409 if (!cfg_hooks
->split_block
)
410 internal_error ("%s does not support split_block", cfg_hooks
->name
);
412 new_bb
= cfg_hooks
->split_block (bb
, i
);
416 new_bb
->count
= bb
->count
;
417 new_bb
->frequency
= bb
->frequency
;
418 new_bb
->loop_depth
= bb
->loop_depth
;
420 if (dom_info_available_p (CDI_DOMINATORS
))
422 redirect_immediate_dominators (CDI_DOMINATORS
, bb
, new_bb
);
423 set_immediate_dominator (CDI_DOMINATORS
, new_bb
, bb
);
426 if (current_loops
!= NULL
)
427 add_bb_to_loop (new_bb
, bb
->loop_father
);
429 return make_single_succ_edge (bb
, new_bb
, EDGE_FALLTHRU
);
432 /* Splits block BB just after labels. The newly created edge is returned. */
435 split_block_after_labels (basic_block bb
)
437 return split_block (bb
, NULL
);
440 /* Moves block BB immediately after block AFTER. Returns false if the
441 movement was impossible. */
444 move_block_after (basic_block bb
, basic_block after
)
448 if (!cfg_hooks
->move_block_after
)
449 internal_error ("%s does not support move_block_after", cfg_hooks
->name
);
451 ret
= cfg_hooks
->move_block_after (bb
, after
);
456 /* Deletes the basic block BB. */
459 delete_basic_block (basic_block bb
)
461 if (!cfg_hooks
->delete_basic_block
)
462 internal_error ("%s does not support delete_basic_block", cfg_hooks
->name
);
464 cfg_hooks
->delete_basic_block (bb
);
466 if (current_loops
!= NULL
)
468 struct loop
*loop
= bb
->loop_father
;
470 /* If we remove the header or the latch of a loop, mark the loop for
471 removal by setting its header and latch to NULL. */
472 if (loop
->latch
== bb
473 || loop
->header
== bb
)
479 remove_bb_from_loops (bb
);
482 /* Remove the edges into and out of this block. Note that there may
483 indeed be edges in, if we are removing an unreachable loop. */
484 while (EDGE_COUNT (bb
->preds
) != 0)
485 remove_edge (EDGE_PRED (bb
, 0));
486 while (EDGE_COUNT (bb
->succs
) != 0)
487 remove_edge (EDGE_SUCC (bb
, 0));
489 if (dom_info_available_p (CDI_DOMINATORS
))
490 delete_from_dominance_info (CDI_DOMINATORS
, bb
);
491 if (dom_info_available_p (CDI_POST_DOMINATORS
))
492 delete_from_dominance_info (CDI_POST_DOMINATORS
, bb
);
494 /* Remove the basic block from the array. */
498 /* Splits edge E and returns the newly created basic block. */
504 gcov_type count
= e
->count
;
505 int freq
= EDGE_FREQUENCY (e
);
507 bool irr
= (e
->flags
& EDGE_IRREDUCIBLE_LOOP
) != 0;
509 basic_block src
= e
->src
, dest
= e
->dest
;
511 if (!cfg_hooks
->split_edge
)
512 internal_error ("%s does not support split_edge", cfg_hooks
->name
);
514 if (current_loops
!= NULL
)
515 rescan_loop_exit (e
, false, true);
517 ret
= cfg_hooks
->split_edge (e
);
519 ret
->frequency
= freq
;
520 single_succ_edge (ret
)->probability
= REG_BR_PROB_BASE
;
521 single_succ_edge (ret
)->count
= count
;
525 ret
->flags
|= BB_IRREDUCIBLE_LOOP
;
526 single_pred_edge (ret
)->flags
|= EDGE_IRREDUCIBLE_LOOP
;
527 single_succ_edge (ret
)->flags
|= EDGE_IRREDUCIBLE_LOOP
;
530 if (dom_info_available_p (CDI_DOMINATORS
))
531 set_immediate_dominator (CDI_DOMINATORS
, ret
, single_pred (ret
));
533 if (dom_info_state (CDI_DOMINATORS
) >= DOM_NO_FAST_QUERY
)
535 /* There are two cases:
537 If the immediate dominator of e->dest is not e->src, it
540 If immediate dominator of e->dest is e->src, it may become
541 ret, provided that all other predecessors of e->dest are
542 dominated by e->dest. */
544 if (get_immediate_dominator (CDI_DOMINATORS
, single_succ (ret
))
545 == single_pred (ret
))
548 FOR_EACH_EDGE (f
, ei
, single_succ (ret
)->preds
)
550 if (f
== single_succ_edge (ret
))
553 if (!dominated_by_p (CDI_DOMINATORS
, f
->src
,
559 set_immediate_dominator (CDI_DOMINATORS
, single_succ (ret
), ret
);
563 if (current_loops
!= NULL
)
565 loop
= find_common_loop (src
->loop_father
, dest
->loop_father
);
566 add_bb_to_loop (ret
, loop
);
568 if (loop
->latch
== src
)
575 /* Creates a new basic block just after the basic block AFTER.
576 HEAD and END are the first and the last statement belonging
577 to the block. If both are NULL, an empty block is created. */
580 create_basic_block (void *head
, void *end
, basic_block after
)
584 if (!cfg_hooks
->create_basic_block
)
585 internal_error ("%s does not support create_basic_block", cfg_hooks
->name
);
587 ret
= cfg_hooks
->create_basic_block (head
, end
, after
);
589 if (dom_info_available_p (CDI_DOMINATORS
))
590 add_to_dominance_info (CDI_DOMINATORS
, ret
);
591 if (dom_info_available_p (CDI_POST_DOMINATORS
))
592 add_to_dominance_info (CDI_POST_DOMINATORS
, ret
);
597 /* Creates an empty basic block just after basic block AFTER. */
600 create_empty_bb (basic_block after
)
602 return create_basic_block (NULL
, NULL
, after
);
605 /* Checks whether we may merge blocks BB1 and BB2. */
608 can_merge_blocks_p (basic_block bb1
, basic_block bb2
)
612 if (!cfg_hooks
->can_merge_blocks_p
)
613 internal_error ("%s does not support can_merge_blocks_p", cfg_hooks
->name
);
615 ret
= cfg_hooks
->can_merge_blocks_p (bb1
, bb2
);
621 predict_edge (edge e
, enum br_predictor predictor
, int probability
)
623 if (!cfg_hooks
->predict_edge
)
624 internal_error ("%s does not support predict_edge", cfg_hooks
->name
);
626 cfg_hooks
->predict_edge (e
, predictor
, probability
);
630 predicted_by_p (basic_block bb
, enum br_predictor predictor
)
632 if (!cfg_hooks
->predict_edge
)
633 internal_error ("%s does not support predicted_by_p", cfg_hooks
->name
);
635 return cfg_hooks
->predicted_by_p (bb
, predictor
);
638 /* Merges basic block B into basic block A. */
641 merge_blocks (basic_block a
, basic_block b
)
646 if (!cfg_hooks
->merge_blocks
)
647 internal_error ("%s does not support merge_blocks", cfg_hooks
->name
);
649 if (current_loops
!= NULL
)
650 remove_bb_from_loops (b
);
652 cfg_hooks
->merge_blocks (a
, b
);
654 /* Normally there should only be one successor of A and that is B, but
655 partway though the merge of blocks for conditional_execution we'll
656 be merging a TEST block with THEN and ELSE successors. Free the
657 whole lot of them and hope the caller knows what they're doing. */
659 while (EDGE_COUNT (a
->succs
) != 0)
661 if (current_loops
!= NULL
)
662 rescan_loop_exit (EDGE_SUCC (a
, 0), false, true);
663 remove_edge (EDGE_SUCC (a
, 0));
666 /* Adjust the edges out of B for the new owner. */
667 FOR_EACH_EDGE (e
, ei
, b
->succs
)
670 if (current_loops
!= NULL
)
671 rescan_loop_exit (e
, true, false);
674 a
->flags
|= b
->flags
;
676 /* B hasn't quite yet ceased to exist. Attempt to prevent mishap. */
677 b
->preds
= b
->succs
= NULL
;
679 if (dom_info_available_p (CDI_DOMINATORS
))
680 redirect_immediate_dominators (CDI_DOMINATORS
, b
, a
);
682 if (dom_info_available_p (CDI_DOMINATORS
))
683 delete_from_dominance_info (CDI_DOMINATORS
, b
);
684 if (dom_info_available_p (CDI_POST_DOMINATORS
))
685 delete_from_dominance_info (CDI_POST_DOMINATORS
, b
);
690 /* Split BB into entry part and the rest (the rest is the newly created block).
691 Redirect those edges for that REDIRECT_EDGE_P returns true to the entry
692 part. Returns the edge connecting the entry part to the rest. */
695 make_forwarder_block (basic_block bb
, bool (*redirect_edge_p
) (edge
),
696 void (*new_bb_cbk
) (basic_block
))
700 basic_block dummy
, jump
;
701 struct loop
*loop
, *ploop
, *cloop
;
703 if (!cfg_hooks
->make_forwarder_block
)
704 internal_error ("%s does not support make_forwarder_block",
707 fallthru
= split_block_after_labels (bb
);
708 dummy
= fallthru
->src
;
711 /* Redirect back edges we want to keep. */
712 for (ei
= ei_start (dummy
->preds
); (e
= ei_safe_edge (ei
)); )
714 if (redirect_edge_p (e
))
720 dummy
->frequency
-= EDGE_FREQUENCY (e
);
721 dummy
->count
-= e
->count
;
722 if (dummy
->frequency
< 0)
723 dummy
->frequency
= 0;
724 if (dummy
->count
< 0)
726 fallthru
->count
-= e
->count
;
727 if (fallthru
->count
< 0)
730 jump
= redirect_edge_and_branch_force (e
, bb
);
732 && new_bb_cbk
!= NULL
)
736 if (dom_info_available_p (CDI_DOMINATORS
))
738 VEC (basic_block
, heap
) *doms_to_fix
= VEC_alloc (basic_block
, heap
, 2);
739 VEC_quick_push (basic_block
, doms_to_fix
, dummy
);
740 VEC_quick_push (basic_block
, doms_to_fix
, bb
);
741 iterate_fix_dominators (CDI_DOMINATORS
, doms_to_fix
, false);
742 VEC_free (basic_block
, heap
, doms_to_fix
);
745 if (current_loops
!= NULL
)
747 /* If we do not split a loop header, then both blocks belong to the
748 same loop. In case we split loop header and do not redirect the
749 latch edge to DUMMY, then DUMMY belongs to the outer loop, and
750 BB becomes the new header. If latch is not recorded for the loop,
751 we leave this updating on the caller (this may only happen during
753 loop
= dummy
->loop_father
;
754 if (loop
->header
== dummy
755 && loop
->latch
!= NULL
756 && find_edge (loop
->latch
, dummy
) == NULL
)
758 remove_bb_from_loops (dummy
);
762 FOR_EACH_EDGE (e
, ei
, dummy
->preds
)
764 cloop
= find_common_loop (cloop
, e
->src
->loop_father
);
766 add_bb_to_loop (dummy
, cloop
);
769 /* In case we split loop latch, update it. */
770 for (ploop
= loop
; ploop
; ploop
= loop_outer (ploop
))
771 if (ploop
->latch
== dummy
)
775 cfg_hooks
->make_forwarder_block (fallthru
);
781 tidy_fallthru_edge (edge e
)
783 if (cfg_hooks
->tidy_fallthru_edge
)
784 cfg_hooks
->tidy_fallthru_edge (e
);
787 /* Fix up edges that now fall through, or rather should now fall through
788 but previously required a jump around now deleted blocks. Simplify
789 the search by only examining blocks numerically adjacent, since this
790 is how find_basic_blocks created them. */
793 tidy_fallthru_edges (void)
797 if (!cfg_hooks
->tidy_fallthru_edge
)
800 if (ENTRY_BLOCK_PTR
->next_bb
== EXIT_BLOCK_PTR
)
803 FOR_BB_BETWEEN (b
, ENTRY_BLOCK_PTR
->next_bb
, EXIT_BLOCK_PTR
->prev_bb
, next_bb
)
809 /* We care about simple conditional or unconditional jumps with
812 If we had a conditional branch to the next instruction when
813 find_basic_blocks was called, then there will only be one
814 out edge for the block which ended with the conditional
815 branch (since we do not create duplicate edges).
817 Furthermore, the edge will be marked as a fallthru because we
818 merge the flags for the duplicate edges. So we do not want to
819 check that the edge is not a FALLTHRU edge. */
821 if (single_succ_p (b
))
823 s
= single_succ_edge (b
);
824 if (! (s
->flags
& EDGE_COMPLEX
)
826 && !find_reg_note (BB_END (b
), REG_CROSSING_JUMP
, NULL_RTX
))
827 tidy_fallthru_edge (s
);
832 /* Returns true if we can duplicate basic block BB. */
835 can_duplicate_block_p (basic_block bb
)
839 if (!cfg_hooks
->can_duplicate_block_p
)
840 internal_error ("%s does not support can_duplicate_block_p",
843 if (bb
== EXIT_BLOCK_PTR
|| bb
== ENTRY_BLOCK_PTR
)
846 /* Duplicating fallthru block to exit would require adding a jump
847 and splitting the real last BB. */
848 e
= find_edge (bb
, EXIT_BLOCK_PTR
);
849 if (e
&& (e
->flags
& EDGE_FALLTHRU
))
852 return cfg_hooks
->can_duplicate_block_p (bb
);
855 /* Duplicates basic block BB and redirects edge E to it. Returns the
856 new basic block. The new basic block is placed after the basic block
860 duplicate_block (basic_block bb
, edge e
, basic_block after
)
864 gcov_type new_count
= e
? e
->count
: 0;
867 if (!cfg_hooks
->duplicate_block
)
868 internal_error ("%s does not support duplicate_block",
871 if (bb
->count
< new_count
)
872 new_count
= bb
->count
;
874 #ifdef ENABLE_CHECKING
875 gcc_assert (can_duplicate_block_p (bb
));
878 new_bb
= cfg_hooks
->duplicate_block (bb
);
880 move_block_after (new_bb
, after
);
882 new_bb
->loop_depth
= bb
->loop_depth
;
883 new_bb
->flags
= bb
->flags
;
884 FOR_EACH_EDGE (s
, ei
, bb
->succs
)
886 /* Since we are creating edges from a new block to successors
887 of another block (which therefore are known to be disjoint), there
888 is no need to actually check for duplicated edges. */
889 n
= unchecked_make_edge (new_bb
, s
->dest
, s
->flags
);
890 n
->probability
= s
->probability
;
893 /* Take care for overflows! */
894 n
->count
= s
->count
* (new_count
* 10000 / bb
->count
) / 10000;
895 s
->count
-= n
->count
;
904 new_bb
->count
= new_count
;
905 bb
->count
-= new_count
;
907 new_bb
->frequency
= EDGE_FREQUENCY (e
);
908 bb
->frequency
-= EDGE_FREQUENCY (e
);
910 redirect_edge_and_branch_force (e
, new_bb
);
914 if (bb
->frequency
< 0)
919 new_bb
->count
= bb
->count
;
920 new_bb
->frequency
= bb
->frequency
;
923 set_bb_original (new_bb
, bb
);
924 set_bb_copy (bb
, new_bb
);
926 /* Add the new block to the copy of the loop of BB, or directly to the loop
927 of BB if the loop is not being copied. */
928 if (current_loops
!= NULL
)
930 struct loop
*cloop
= bb
->loop_father
;
931 struct loop
*copy
= get_loop_copy (cloop
);
932 add_bb_to_loop (new_bb
, copy
? copy
: cloop
);
938 /* Return 1 if BB ends with a call, possibly followed by some
939 instructions that must stay with the call, 0 otherwise. */
942 block_ends_with_call_p (basic_block bb
)
944 if (!cfg_hooks
->block_ends_with_call_p
)
945 internal_error ("%s does not support block_ends_with_call_p", cfg_hooks
->name
);
947 return (cfg_hooks
->block_ends_with_call_p
) (bb
);
950 /* Return 1 if BB ends with a conditional branch, 0 otherwise. */
953 block_ends_with_condjump_p (basic_block bb
)
955 if (!cfg_hooks
->block_ends_with_condjump_p
)
956 internal_error ("%s does not support block_ends_with_condjump_p",
959 return (cfg_hooks
->block_ends_with_condjump_p
) (bb
);
962 /* Add fake edges to the function exit for any non constant and non noreturn
963 calls, volatile inline assembly in the bitmap of blocks specified by
964 BLOCKS or to the whole CFG if BLOCKS is zero. Return the number of blocks
967 The goal is to expose cases in which entering a basic block does not imply
968 that all subsequent instructions must be executed. */
971 flow_call_edges_add (sbitmap blocks
)
973 if (!cfg_hooks
->flow_call_edges_add
)
974 internal_error ("%s does not support flow_call_edges_add",
977 return (cfg_hooks
->flow_call_edges_add
) (blocks
);
980 /* This function is called immediately after edge E is added to the
981 edge vector E->dest->preds. */
984 execute_on_growing_pred (edge e
)
986 if (cfg_hooks
->execute_on_growing_pred
)
987 cfg_hooks
->execute_on_growing_pred (e
);
990 /* This function is called immediately before edge E is removed from
991 the edge vector E->dest->preds. */
994 execute_on_shrinking_pred (edge e
)
996 if (cfg_hooks
->execute_on_shrinking_pred
)
997 cfg_hooks
->execute_on_shrinking_pred (e
);
1000 /* This is used inside loop versioning when we want to insert
1001 stmts/insns on the edges, which have a different behavior
1002 in tree's and in RTL, so we made a CFG hook. */
1004 lv_flush_pending_stmts (edge e
)
1006 if (cfg_hooks
->flush_pending_stmts
)
1007 cfg_hooks
->flush_pending_stmts (e
);
1010 /* Loop versioning uses the duplicate_loop_to_header_edge to create
1011 a new version of the loop basic-blocks, the parameters here are
1012 exactly the same as in duplicate_loop_to_header_edge or
1013 tree_duplicate_loop_to_header_edge; while in tree-ssa there is
1014 additional work to maintain ssa information that's why there is
1015 a need to call the tree_duplicate_loop_to_header_edge rather
1016 than duplicate_loop_to_header_edge when we are in tree mode. */
1018 cfg_hook_duplicate_loop_to_header_edge (struct loop
*loop
, edge e
,
1020 sbitmap wont_exit
, edge orig
,
1021 VEC (edge
, heap
) **to_remove
,
1024 gcc_assert (cfg_hooks
->cfg_hook_duplicate_loop_to_header_edge
);
1025 return cfg_hooks
->cfg_hook_duplicate_loop_to_header_edge (loop
, e
,
1031 /* Conditional jumps are represented differently in trees and RTL,
1032 this hook takes a basic block that is known to have a cond jump
1033 at its end and extracts the taken and not taken eges out of it
1034 and store it in E1 and E2 respectively. */
1036 extract_cond_bb_edges (basic_block b
, edge
*e1
, edge
*e2
)
1038 gcc_assert (cfg_hooks
->extract_cond_bb_edges
);
1039 cfg_hooks
->extract_cond_bb_edges (b
, e1
, e2
);
1042 /* Responsible for updating the ssa info (PHI nodes) on the
1043 new condition basic block that guards the versioned loop. */
1045 lv_adjust_loop_header_phi (basic_block first
, basic_block second
,
1046 basic_block new_block
, edge e
)
1048 if (cfg_hooks
->lv_adjust_loop_header_phi
)
1049 cfg_hooks
->lv_adjust_loop_header_phi (first
, second
, new_block
, e
);
1052 /* Conditions in trees and RTL are different so we need
1053 a different handling when we add the condition to the
1056 lv_add_condition_to_bb (basic_block first
, basic_block second
,
1057 basic_block new_block
, void *cond
)
1059 gcc_assert (cfg_hooks
->lv_add_condition_to_bb
);
1060 cfg_hooks
->lv_add_condition_to_bb (first
, second
, new_block
, cond
);