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
= 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 /* Redirect the edge E to basic block DEST even if it requires creating
322 of a new basic block; then it returns the newly created basic block.
323 Aborts when redirection is impossible. */
326 redirect_edge_and_branch_force (edge e
, basic_block dest
)
328 basic_block ret
, src
= e
->src
;
331 if (!cfg_hooks
->redirect_edge_and_branch_force
)
332 internal_error ("%s does not support redirect_edge_and_branch_force",
335 if (current_loops
!= NULL
)
336 rescan_loop_exit (e
, false, true);
338 ret
= cfg_hooks
->redirect_edge_and_branch_force (e
, dest
);
339 if (current_loops
!= NULL
)
343 loop
= find_common_loop (single_pred (ret
)->loop_father
,
344 single_succ (ret
)->loop_father
);
345 add_bb_to_loop (ret
, loop
);
347 else if (find_edge (src
, dest
) == e
)
348 rescan_loop_exit (e
, true, false);
354 /* Splits basic block BB after the specified instruction I (but at least after
355 the labels). If I is NULL, splits just after labels. The newly created edge
356 is returned. The new basic block is created just after the old one. */
359 split_block (basic_block bb
, void *i
)
363 if (!cfg_hooks
->split_block
)
364 internal_error ("%s does not support split_block", cfg_hooks
->name
);
366 new_bb
= cfg_hooks
->split_block (bb
, i
);
370 new_bb
->count
= bb
->count
;
371 new_bb
->frequency
= bb
->frequency
;
372 new_bb
->loop_depth
= bb
->loop_depth
;
374 if (dom_info_available_p (CDI_DOMINATORS
))
376 redirect_immediate_dominators (CDI_DOMINATORS
, bb
, new_bb
);
377 set_immediate_dominator (CDI_DOMINATORS
, new_bb
, bb
);
380 if (current_loops
!= NULL
)
381 add_bb_to_loop (new_bb
, bb
->loop_father
);
383 return make_single_succ_edge (bb
, new_bb
, EDGE_FALLTHRU
);
386 /* Splits block BB just after labels. The newly created edge is returned. */
389 split_block_after_labels (basic_block bb
)
391 return split_block (bb
, NULL
);
394 /* Moves block BB immediately after block AFTER. Returns false if the
395 movement was impossible. */
398 move_block_after (basic_block bb
, basic_block after
)
402 if (!cfg_hooks
->move_block_after
)
403 internal_error ("%s does not support move_block_after", cfg_hooks
->name
);
405 ret
= cfg_hooks
->move_block_after (bb
, after
);
410 /* Deletes the basic block BB. */
413 delete_basic_block (basic_block bb
)
415 if (!cfg_hooks
->delete_basic_block
)
416 internal_error ("%s does not support delete_basic_block", cfg_hooks
->name
);
418 cfg_hooks
->delete_basic_block (bb
);
420 if (current_loops
!= NULL
)
422 struct loop
*loop
= bb
->loop_father
;
424 /* If we remove the header or the latch of a loop, mark the loop for
425 removal by setting its header and latch to NULL. */
426 if (loop
->latch
== bb
427 || loop
->header
== bb
)
433 remove_bb_from_loops (bb
);
436 /* Remove the edges into and out of this block. Note that there may
437 indeed be edges in, if we are removing an unreachable loop. */
438 while (EDGE_COUNT (bb
->preds
) != 0)
439 remove_edge (EDGE_PRED (bb
, 0));
440 while (EDGE_COUNT (bb
->succs
) != 0)
441 remove_edge (EDGE_SUCC (bb
, 0));
443 if (dom_computed
[CDI_DOMINATORS
])
444 delete_from_dominance_info (CDI_DOMINATORS
, bb
);
445 if (dom_computed
[CDI_POST_DOMINATORS
])
446 delete_from_dominance_info (CDI_POST_DOMINATORS
, bb
);
448 /* Remove the basic block from the array. */
452 /* Splits edge E and returns the newly created basic block. */
458 gcov_type count
= e
->count
;
459 int freq
= EDGE_FREQUENCY (e
);
461 bool irr
= (e
->flags
& EDGE_IRREDUCIBLE_LOOP
) != 0;
463 basic_block src
= e
->src
, dest
= e
->dest
;
465 if (!cfg_hooks
->split_edge
)
466 internal_error ("%s does not support split_edge", cfg_hooks
->name
);
468 if (current_loops
!= NULL
)
469 rescan_loop_exit (e
, false, true);
471 ret
= cfg_hooks
->split_edge (e
);
473 ret
->frequency
= freq
;
474 single_succ_edge (ret
)->probability
= REG_BR_PROB_BASE
;
475 single_succ_edge (ret
)->count
= count
;
479 ret
->flags
|= BB_IRREDUCIBLE_LOOP
;
480 single_pred_edge (ret
)->flags
|= EDGE_IRREDUCIBLE_LOOP
;
481 single_succ_edge (ret
)->flags
|= EDGE_IRREDUCIBLE_LOOP
;
484 if (dom_computed
[CDI_DOMINATORS
])
485 set_immediate_dominator (CDI_DOMINATORS
, ret
, single_pred (ret
));
487 if (dom_computed
[CDI_DOMINATORS
] >= DOM_NO_FAST_QUERY
)
489 /* There are two cases:
491 If the immediate dominator of e->dest is not e->src, it
494 If immediate dominator of e->dest is e->src, it may become
495 ret, provided that all other predecessors of e->dest are
496 dominated by e->dest. */
498 if (get_immediate_dominator (CDI_DOMINATORS
, single_succ (ret
))
499 == single_pred (ret
))
502 FOR_EACH_EDGE (f
, ei
, single_succ (ret
)->preds
)
504 if (f
== single_succ_edge (ret
))
507 if (!dominated_by_p (CDI_DOMINATORS
, f
->src
,
513 set_immediate_dominator (CDI_DOMINATORS
, single_succ (ret
), ret
);
517 if (current_loops
!= NULL
)
519 loop
= find_common_loop (src
->loop_father
, dest
->loop_father
);
520 add_bb_to_loop (ret
, loop
);
522 if (loop
->latch
== src
)
529 /* Creates a new basic block just after the basic block AFTER.
530 HEAD and END are the first and the last statement belonging
531 to the block. If both are NULL, an empty block is created. */
534 create_basic_block (void *head
, void *end
, basic_block after
)
538 if (!cfg_hooks
->create_basic_block
)
539 internal_error ("%s does not support create_basic_block", cfg_hooks
->name
);
541 ret
= cfg_hooks
->create_basic_block (head
, end
, after
);
543 if (dom_computed
[CDI_DOMINATORS
])
544 add_to_dominance_info (CDI_DOMINATORS
, ret
);
545 if (dom_computed
[CDI_POST_DOMINATORS
])
546 add_to_dominance_info (CDI_POST_DOMINATORS
, ret
);
551 /* Creates an empty basic block just after basic block AFTER. */
554 create_empty_bb (basic_block after
)
556 return create_basic_block (NULL
, NULL
, after
);
559 /* Checks whether we may merge blocks BB1 and BB2. */
562 can_merge_blocks_p (basic_block bb1
, basic_block bb2
)
566 if (!cfg_hooks
->can_merge_blocks_p
)
567 internal_error ("%s does not support can_merge_blocks_p", cfg_hooks
->name
);
569 ret
= cfg_hooks
->can_merge_blocks_p (bb1
, bb2
);
575 predict_edge (edge e
, enum br_predictor predictor
, int probability
)
577 if (!cfg_hooks
->predict_edge
)
578 internal_error ("%s does not support predict_edge", cfg_hooks
->name
);
580 cfg_hooks
->predict_edge (e
, predictor
, probability
);
584 predicted_by_p (basic_block bb
, enum br_predictor predictor
)
586 if (!cfg_hooks
->predict_edge
)
587 internal_error ("%s does not support predicted_by_p", cfg_hooks
->name
);
589 return cfg_hooks
->predicted_by_p (bb
, predictor
);
592 /* Merges basic block B into basic block A. */
595 merge_blocks (basic_block a
, basic_block b
)
600 if (!cfg_hooks
->merge_blocks
)
601 internal_error ("%s does not support merge_blocks", cfg_hooks
->name
);
603 if (current_loops
!= NULL
)
604 remove_bb_from_loops (b
);
606 cfg_hooks
->merge_blocks (a
, b
);
608 /* Normally there should only be one successor of A and that is B, but
609 partway though the merge of blocks for conditional_execution we'll
610 be merging a TEST block with THEN and ELSE successors. Free the
611 whole lot of them and hope the caller knows what they're doing. */
613 while (EDGE_COUNT (a
->succs
) != 0)
615 if (current_loops
!= NULL
)
616 rescan_loop_exit (EDGE_SUCC (a
, 0), false, true);
617 remove_edge (EDGE_SUCC (a
, 0));
620 /* Adjust the edges out of B for the new owner. */
621 FOR_EACH_EDGE (e
, ei
, b
->succs
)
624 if (current_loops
!= NULL
)
625 rescan_loop_exit (e
, true, false);
628 a
->flags
|= b
->flags
;
630 /* B hasn't quite yet ceased to exist. Attempt to prevent mishap. */
631 b
->preds
= b
->succs
= NULL
;
633 if (dom_computed
[CDI_DOMINATORS
])
634 redirect_immediate_dominators (CDI_DOMINATORS
, b
, a
);
636 if (dom_computed
[CDI_DOMINATORS
])
637 delete_from_dominance_info (CDI_DOMINATORS
, b
);
638 if (dom_computed
[CDI_POST_DOMINATORS
])
639 delete_from_dominance_info (CDI_POST_DOMINATORS
, b
);
644 /* Split BB into entry part and the rest (the rest is the newly created block).
645 Redirect those edges for that REDIRECT_EDGE_P returns true to the entry
646 part. Returns the edge connecting the entry part to the rest. */
649 make_forwarder_block (basic_block bb
, bool (*redirect_edge_p
) (edge
),
650 void (*new_bb_cbk
) (basic_block
))
654 basic_block dummy
, jump
;
655 struct loop
*loop
, *ploop
, *cloop
;
657 if (!cfg_hooks
->make_forwarder_block
)
658 internal_error ("%s does not support make_forwarder_block",
661 fallthru
= split_block_after_labels (bb
);
662 dummy
= fallthru
->src
;
665 /* Redirect back edges we want to keep. */
666 for (ei
= ei_start (dummy
->preds
); (e
= ei_safe_edge (ei
)); )
668 if (redirect_edge_p (e
))
674 dummy
->frequency
-= EDGE_FREQUENCY (e
);
675 dummy
->count
-= e
->count
;
676 if (dummy
->frequency
< 0)
677 dummy
->frequency
= 0;
678 if (dummy
->count
< 0)
680 fallthru
->count
-= e
->count
;
681 if (fallthru
->count
< 0)
684 jump
= redirect_edge_and_branch_force (e
, bb
);
689 if (dom_info_available_p (CDI_DOMINATORS
))
691 basic_block doms_to_fix
[2];
693 doms_to_fix
[0] = dummy
;
695 iterate_fix_dominators (CDI_DOMINATORS
, doms_to_fix
, 2);
698 if (current_loops
!= NULL
)
700 /* If we do not split a loop header, then both blocks belong to the
701 same loop. In case we split loop header and do not redirect the
702 latch edge to DUMMY, then DUMMY belongs to the outer loop, and
703 BB becomes the new header. */
704 loop
= dummy
->loop_father
;
705 if (loop
->header
== dummy
706 && find_edge (loop
->latch
, dummy
) == NULL
)
708 remove_bb_from_loops (dummy
);
712 FOR_EACH_EDGE (e
, ei
, dummy
->preds
)
714 cloop
= find_common_loop (cloop
, e
->src
->loop_father
);
716 add_bb_to_loop (dummy
, cloop
);
719 /* In case we split loop latch, update it. */
720 for (ploop
= loop
; ploop
; ploop
= ploop
->outer
)
721 if (ploop
->latch
== dummy
)
725 cfg_hooks
->make_forwarder_block (fallthru
);
731 tidy_fallthru_edge (edge e
)
733 if (cfg_hooks
->tidy_fallthru_edge
)
734 cfg_hooks
->tidy_fallthru_edge (e
);
737 /* Fix up edges that now fall through, or rather should now fall through
738 but previously required a jump around now deleted blocks. Simplify
739 the search by only examining blocks numerically adjacent, since this
740 is how find_basic_blocks created them. */
743 tidy_fallthru_edges (void)
747 if (!cfg_hooks
->tidy_fallthru_edge
)
750 if (ENTRY_BLOCK_PTR
->next_bb
== EXIT_BLOCK_PTR
)
753 FOR_BB_BETWEEN (b
, ENTRY_BLOCK_PTR
->next_bb
, EXIT_BLOCK_PTR
->prev_bb
, next_bb
)
759 /* We care about simple conditional or unconditional jumps with
762 If we had a conditional branch to the next instruction when
763 find_basic_blocks was called, then there will only be one
764 out edge for the block which ended with the conditional
765 branch (since we do not create duplicate edges).
767 Furthermore, the edge will be marked as a fallthru because we
768 merge the flags for the duplicate edges. So we do not want to
769 check that the edge is not a FALLTHRU edge. */
771 if (single_succ_p (b
))
773 s
= single_succ_edge (b
);
774 if (! (s
->flags
& EDGE_COMPLEX
)
776 && !find_reg_note (BB_END (b
), REG_CROSSING_JUMP
, NULL_RTX
))
777 tidy_fallthru_edge (s
);
782 /* Returns true if we can duplicate basic block BB. */
785 can_duplicate_block_p (basic_block bb
)
789 if (!cfg_hooks
->can_duplicate_block_p
)
790 internal_error ("%s does not support can_duplicate_block_p",
793 if (bb
== EXIT_BLOCK_PTR
|| bb
== ENTRY_BLOCK_PTR
)
796 /* Duplicating fallthru block to exit would require adding a jump
797 and splitting the real last BB. */
798 e
= find_edge (bb
, EXIT_BLOCK_PTR
);
799 if (e
&& (e
->flags
& EDGE_FALLTHRU
))
802 return cfg_hooks
->can_duplicate_block_p (bb
);
805 /* Duplicates basic block BB and redirects edge E to it. Returns the
806 new basic block. The new basic block is placed after the basic block
810 duplicate_block (basic_block bb
, edge e
, basic_block after
)
814 gcov_type new_count
= e
? e
->count
: 0;
817 if (!cfg_hooks
->duplicate_block
)
818 internal_error ("%s does not support duplicate_block",
821 if (bb
->count
< new_count
)
822 new_count
= bb
->count
;
824 #ifdef ENABLE_CHECKING
825 gcc_assert (can_duplicate_block_p (bb
));
828 new_bb
= cfg_hooks
->duplicate_block (bb
);
830 move_block_after (new_bb
, after
);
832 new_bb
->loop_depth
= bb
->loop_depth
;
833 new_bb
->flags
= bb
->flags
;
834 FOR_EACH_EDGE (s
, ei
, bb
->succs
)
836 /* Since we are creating edges from a new block to successors
837 of another block (which therefore are known to be disjoint), there
838 is no need to actually check for duplicated edges. */
839 n
= unchecked_make_edge (new_bb
, s
->dest
, s
->flags
);
840 n
->probability
= s
->probability
;
843 /* Take care for overflows! */
844 n
->count
= s
->count
* (new_count
* 10000 / bb
->count
) / 10000;
845 s
->count
-= n
->count
;
854 new_bb
->count
= new_count
;
855 bb
->count
-= new_count
;
857 new_bb
->frequency
= EDGE_FREQUENCY (e
);
858 bb
->frequency
-= EDGE_FREQUENCY (e
);
860 redirect_edge_and_branch_force (e
, new_bb
);
864 if (bb
->frequency
< 0)
869 new_bb
->count
= bb
->count
;
870 new_bb
->frequency
= bb
->frequency
;
873 set_bb_original (new_bb
, bb
);
874 set_bb_copy (bb
, new_bb
);
876 /* Add the new block to the prescribed loop. */
877 if (current_loops
!= NULL
)
878 add_bb_to_loop (new_bb
, bb
->loop_father
->copy
);
883 /* Return 1 if BB ends with a call, possibly followed by some
884 instructions that must stay with the call, 0 otherwise. */
887 block_ends_with_call_p (basic_block bb
)
889 if (!cfg_hooks
->block_ends_with_call_p
)
890 internal_error ("%s does not support block_ends_with_call_p", cfg_hooks
->name
);
892 return (cfg_hooks
->block_ends_with_call_p
) (bb
);
895 /* Return 1 if BB ends with a conditional branch, 0 otherwise. */
898 block_ends_with_condjump_p (basic_block bb
)
900 if (!cfg_hooks
->block_ends_with_condjump_p
)
901 internal_error ("%s does not support block_ends_with_condjump_p",
904 return (cfg_hooks
->block_ends_with_condjump_p
) (bb
);
907 /* Add fake edges to the function exit for any non constant and non noreturn
908 calls, volatile inline assembly in the bitmap of blocks specified by
909 BLOCKS or to the whole CFG if BLOCKS is zero. Return the number of blocks
912 The goal is to expose cases in which entering a basic block does not imply
913 that all subsequent instructions must be executed. */
916 flow_call_edges_add (sbitmap blocks
)
918 if (!cfg_hooks
->flow_call_edges_add
)
919 internal_error ("%s does not support flow_call_edges_add",
922 return (cfg_hooks
->flow_call_edges_add
) (blocks
);
925 /* This function is called immediately after edge E is added to the
926 edge vector E->dest->preds. */
929 execute_on_growing_pred (edge e
)
931 if (cfg_hooks
->execute_on_growing_pred
)
932 cfg_hooks
->execute_on_growing_pred (e
);
935 /* This function is called immediately before edge E is removed from
936 the edge vector E->dest->preds. */
939 execute_on_shrinking_pred (edge e
)
941 if (cfg_hooks
->execute_on_shrinking_pred
)
942 cfg_hooks
->execute_on_shrinking_pred (e
);
945 /* This is used inside loop versioning when we want to insert
946 stmts/insns on the edges, which have a different behavior
947 in tree's and in RTL, so we made a CFG hook. */
949 lv_flush_pending_stmts (edge e
)
951 if (cfg_hooks
->flush_pending_stmts
)
952 cfg_hooks
->flush_pending_stmts (e
);
955 /* Loop versioning uses the duplicate_loop_to_header_edge to create
956 a new version of the loop basic-blocks, the parameters here are
957 exactly the same as in duplicate_loop_to_header_edge or
958 tree_duplicate_loop_to_header_edge; while in tree-ssa there is
959 additional work to maintain ssa information that's why there is
960 a need to call the tree_duplicate_loop_to_header_edge rather
961 than duplicate_loop_to_header_edge when we are in tree mode. */
963 cfg_hook_duplicate_loop_to_header_edge (struct loop
*loop
, edge e
,
965 sbitmap wont_exit
, edge orig
,
966 VEC (edge
, heap
) **to_remove
,
969 gcc_assert (cfg_hooks
->cfg_hook_duplicate_loop_to_header_edge
);
970 return cfg_hooks
->cfg_hook_duplicate_loop_to_header_edge (loop
, e
,
976 /* Conditional jumps are represented differently in trees and RTL,
977 this hook takes a basic block that is known to have a cond jump
978 at its end and extracts the taken and not taken eges out of it
979 and store it in E1 and E2 respectively. */
981 extract_cond_bb_edges (basic_block b
, edge
*e1
, edge
*e2
)
983 gcc_assert (cfg_hooks
->extract_cond_bb_edges
);
984 cfg_hooks
->extract_cond_bb_edges (b
, e1
, e2
);
987 /* Responsible for updating the ssa info (PHI nodes) on the
988 new condition basic block that guards the versioned loop. */
990 lv_adjust_loop_header_phi (basic_block first
, basic_block second
,
991 basic_block
new, edge e
)
993 if (cfg_hooks
->lv_adjust_loop_header_phi
)
994 cfg_hooks
->lv_adjust_loop_header_phi (first
, second
, new, e
);
997 /* Conditions in trees and RTL are different so we need
998 a different handling when we add the condition to the
1001 lv_add_condition_to_bb (basic_block first
, basic_block second
,
1002 basic_block
new, void *cond
)
1004 gcc_assert (cfg_hooks
->lv_add_condition_to_bb
);
1005 cfg_hooks
->lv_add_condition_to_bb (first
, second
, new, cond
);