1 /* Hooks for cfg representation specific functions.
2 Copyright (C) 2003-2016 Free Software Foundation, Inc.
3 Contributed by Sebastian Pop <s.pop@laposte.net>
4
5 This file is part of GCC.
6
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 3, or (at your option)
10 any later version.
11
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.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
20
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "backend.h"
25 #include "rtl.h"
26 #include "cfghooks.h"
27 #include "timevar.h"
28 #include "pretty-print.h"
29 #include "diagnostic-core.h"
30 #include "dumpfile.h"
31 #include "cfganal.h"
32 #include "tree-ssa.h"
33 #include "cfgloop.h"
34
35 /* A pointer to one of the hooks containers. */
36 static struct cfg_hooks *cfg_hooks;
37
38 /* Initialization of functions specific to the rtl IR. */
39 void
rtl_register_cfg_hooks(void)40 rtl_register_cfg_hooks (void)
41 {
42 cfg_hooks = &rtl_cfg_hooks;
43 }
44
45 /* Initialization of functions specific to the rtl IR. */
46 void
cfg_layout_rtl_register_cfg_hooks(void)47 cfg_layout_rtl_register_cfg_hooks (void)
48 {
49 cfg_hooks = &cfg_layout_rtl_cfg_hooks;
50 }
51
52 /* Initialization of functions specific to the tree IR. */
53
54 void
gimple_register_cfg_hooks(void)55 gimple_register_cfg_hooks (void)
56 {
57 cfg_hooks = &gimple_cfg_hooks;
58 }
59
60 struct cfg_hooks
get_cfg_hooks(void)61 get_cfg_hooks (void)
62 {
63 return *cfg_hooks;
64 }
65
66 void
set_cfg_hooks(struct cfg_hooks new_cfg_hooks)67 set_cfg_hooks (struct cfg_hooks new_cfg_hooks)
68 {
69 *cfg_hooks = new_cfg_hooks;
70 }
71
72 /* Returns current ir type. */
73
74 enum ir_type
current_ir_type(void)75 current_ir_type (void)
76 {
77 if (cfg_hooks == &gimple_cfg_hooks)
78 return IR_GIMPLE;
79 else if (cfg_hooks == &rtl_cfg_hooks)
80 return IR_RTL_CFGRTL;
81 else if (cfg_hooks == &cfg_layout_rtl_cfg_hooks)
82 return IR_RTL_CFGLAYOUT;
83 else
84 gcc_unreachable ();
85 }
86
87 /* Verify the CFG consistency.
88
89 Currently it does following: checks edge and basic block list correctness
90 and calls into IL dependent checking then. */
91
92 DEBUG_FUNCTION void
verify_flow_info(void)93 verify_flow_info (void)
94 {
95 size_t *edge_checksum;
96 int err = 0;
97 basic_block bb, last_bb_seen;
98 basic_block *last_visited;
99
100 timevar_push (TV_CFG_VERIFY);
101 last_visited = XCNEWVEC (basic_block, last_basic_block_for_fn (cfun));
102 edge_checksum = XCNEWVEC (size_t, last_basic_block_for_fn (cfun));
103
104 /* Check bb chain & numbers. */
105 last_bb_seen = ENTRY_BLOCK_PTR_FOR_FN (cfun);
106 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb, NULL, next_bb)
107 {
108 if (bb != EXIT_BLOCK_PTR_FOR_FN (cfun)
109 && bb != BASIC_BLOCK_FOR_FN (cfun, bb->index))
110 {
111 error ("bb %d on wrong place", bb->index);
112 err = 1;
113 }
114
115 if (bb->prev_bb != last_bb_seen)
116 {
117 error ("prev_bb of %d should be %d, not %d",
118 bb->index, last_bb_seen->index, bb->prev_bb->index);
119 err = 1;
120 }
121
122 last_bb_seen = bb;
123 }
124
125 /* Now check the basic blocks (boundaries etc.) */
126 FOR_EACH_BB_REVERSE_FN (bb, cfun)
127 {
128 int n_fallthru = 0;
129 edge e;
130 edge_iterator ei;
131
132 if (bb->loop_father != NULL && current_loops == NULL)
133 {
134 error ("verify_flow_info: Block %i has loop_father, but there are no loops",
135 bb->index);
136 err = 1;
137 }
138 if (bb->loop_father == NULL && current_loops != NULL)
139 {
140 error ("verify_flow_info: Block %i lacks loop_father", bb->index);
141 err = 1;
142 }
143
144 if (bb->count < 0)
145 {
146 error ("verify_flow_info: Wrong count of block %i %i",
147 bb->index, (int)bb->count);
148 err = 1;
149 }
150 if (bb->frequency < 0)
151 {
152 error ("verify_flow_info: Wrong frequency of block %i %i",
153 bb->index, bb->frequency);
154 err = 1;
155 }
156 FOR_EACH_EDGE (e, ei, bb->succs)
157 {
158 if (last_visited [e->dest->index] == bb)
159 {
160 error ("verify_flow_info: Duplicate edge %i->%i",
161 e->src->index, e->dest->index);
162 err = 1;
163 }
164 if (e->probability < 0 || e->probability > REG_BR_PROB_BASE)
165 {
166 error ("verify_flow_info: Wrong probability of edge %i->%i %i",
167 e->src->index, e->dest->index, e->probability);
168 err = 1;
169 }
170 if (e->count < 0)
171 {
172 error ("verify_flow_info: Wrong count of edge %i->%i %i",
173 e->src->index, e->dest->index, (int)e->count);
174 err = 1;
175 }
176
177 last_visited [e->dest->index] = bb;
178
179 if (e->flags & EDGE_FALLTHRU)
180 n_fallthru++;
181
182 if (e->src != bb)
183 {
184 error ("verify_flow_info: Basic block %d succ edge is corrupted",
185 bb->index);
186 fprintf (stderr, "Predecessor: ");
187 dump_edge_info (stderr, e, TDF_DETAILS, 0);
188 fprintf (stderr, "\nSuccessor: ");
189 dump_edge_info (stderr, e, TDF_DETAILS, 1);
190 fprintf (stderr, "\n");
191 err = 1;
192 }
193
194 edge_checksum[e->dest->index] += (size_t) e;
195 }
196 if (n_fallthru > 1)
197 {
198 error ("wrong amount of branch edges after unconditional jump %i", bb->index);
199 err = 1;
200 }
201
202 FOR_EACH_EDGE (e, ei, bb->preds)
203 {
204 if (e->dest != bb)
205 {
206 error ("basic block %d pred edge is corrupted", bb->index);
207 fputs ("Predecessor: ", stderr);
208 dump_edge_info (stderr, e, TDF_DETAILS, 0);
209 fputs ("\nSuccessor: ", stderr);
210 dump_edge_info (stderr, e, TDF_DETAILS, 1);
211 fputc ('\n', stderr);
212 err = 1;
213 }
214
215 if (ei.index != e->dest_idx)
216 {
217 error ("basic block %d pred edge is corrupted", bb->index);
218 error ("its dest_idx should be %d, not %d",
219 ei.index, e->dest_idx);
220 fputs ("Predecessor: ", stderr);
221 dump_edge_info (stderr, e, TDF_DETAILS, 0);
222 fputs ("\nSuccessor: ", stderr);
223 dump_edge_info (stderr, e, TDF_DETAILS, 1);
224 fputc ('\n', stderr);
225 err = 1;
226 }
227
228 edge_checksum[e->dest->index] -= (size_t) e;
229 }
230 }
231
232 /* Complete edge checksumming for ENTRY and EXIT. */
233 {
234 edge e;
235 edge_iterator ei;
236
237 FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs)
238 edge_checksum[e->dest->index] += (size_t) e;
239
240 FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)
241 edge_checksum[e->dest->index] -= (size_t) e;
242 }
243
244 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, next_bb)
245 if (edge_checksum[bb->index])
246 {
247 error ("basic block %i edge lists are corrupted", bb->index);
248 err = 1;
249 }
250
251 last_bb_seen = ENTRY_BLOCK_PTR_FOR_FN (cfun);
252
253 /* Clean up. */
254 free (last_visited);
255 free (edge_checksum);
256
257 if (cfg_hooks->verify_flow_info)
258 err |= cfg_hooks->verify_flow_info ();
259 if (err)
260 internal_error ("verify_flow_info failed");
261 timevar_pop (TV_CFG_VERIFY);
262 }
263
264 /* Print out one basic block BB to file OUTF. INDENT is printed at the
265 start of each new line. FLAGS are the TDF_* flags in dumpfile.h.
266
267 This function takes care of the purely graph related information.
268 The cfg hook for the active representation should dump
269 representation-specific information. */
270
271 void
dump_bb(FILE * outf,basic_block bb,int indent,int flags)272 dump_bb (FILE *outf, basic_block bb, int indent, int flags)
273 {
274 if (flags & TDF_BLOCKS)
275 dump_bb_info (outf, bb, indent, flags, true, false);
276 if (cfg_hooks->dump_bb)
277 cfg_hooks->dump_bb (outf, bb, indent, flags);
278 if (flags & TDF_BLOCKS)
279 dump_bb_info (outf, bb, indent, flags, false, true);
280 fputc ('\n', outf);
281 }
282
283 DEBUG_FUNCTION void
debug(basic_block_def & ref)284 debug (basic_block_def &ref)
285 {
286 dump_bb (stderr, &ref, 0, 0);
287 }
288
289 DEBUG_FUNCTION void
debug(basic_block_def * ptr)290 debug (basic_block_def *ptr)
291 {
292 if (ptr)
293 debug (*ptr);
294 else
295 fprintf (stderr, "<nil>\n");
296 }
297
298
299 /* Dumps basic block BB to pretty-printer PP, for use as a label of
300 a DOT graph record-node. The implementation of this hook is
301 expected to write the label to the stream that is attached to PP.
302 Field separators between instructions are pipe characters printed
303 verbatim. Instructions should be written with some characters
304 escaped, using pp_write_text_as_dot_label_to_stream(). */
305
306 void
dump_bb_for_graph(pretty_printer * pp,basic_block bb)307 dump_bb_for_graph (pretty_printer *pp, basic_block bb)
308 {
309 if (!cfg_hooks->dump_bb_for_graph)
310 internal_error ("%s does not support dump_bb_for_graph",
311 cfg_hooks->name);
312 if (bb->count)
313 pp_printf (pp, "COUNT:" "%" PRId64, bb->count);
314 pp_printf (pp, " FREQ:%i |", bb->frequency);
315 pp_write_text_to_stream (pp);
316 if (!(dump_flags & TDF_SLIM))
317 cfg_hooks->dump_bb_for_graph (pp, bb);
318 }
319
320 /* Dump the complete CFG to FILE. FLAGS are the TDF_* flags in dumpfile.h. */
321 void
dump_flow_info(FILE * file,int flags)322 dump_flow_info (FILE *file, int flags)
323 {
324 basic_block bb;
325
326 fprintf (file, "\n%d basic blocks, %d edges.\n", n_basic_blocks_for_fn (cfun),
327 n_edges_for_fn (cfun));
328 FOR_ALL_BB_FN (bb, cfun)
329 dump_bb (file, bb, 0, flags);
330
331 putc ('\n', file);
332 }
333
334 /* Like above, but dump to stderr. To be called from debuggers. */
335 void debug_flow_info (void);
336 DEBUG_FUNCTION void
debug_flow_info(void)337 debug_flow_info (void)
338 {
339 dump_flow_info (stderr, TDF_DETAILS);
340 }
341
342 /* Redirect edge E to the given basic block DEST and update underlying program
343 representation. Returns edge representing redirected branch (that may not
344 be equivalent to E in the case of duplicate edges being removed) or NULL
345 if edge is not easily redirectable for whatever reason. */
346
347 edge
redirect_edge_and_branch(edge e,basic_block dest)348 redirect_edge_and_branch (edge e, basic_block dest)
349 {
350 edge ret;
351
352 if (!cfg_hooks->redirect_edge_and_branch)
353 internal_error ("%s does not support redirect_edge_and_branch",
354 cfg_hooks->name);
355
356 ret = cfg_hooks->redirect_edge_and_branch (e, dest);
357
358 /* If RET != E, then either the redirection failed, or the edge E
359 was removed since RET already lead to the same destination. */
360 if (current_loops != NULL && ret == e)
361 rescan_loop_exit (e, false, false);
362
363 return ret;
364 }
365
366 /* Returns true if it is possible to remove the edge E by redirecting it
367 to the destination of the other edge going from its source. */
368
369 bool
can_remove_branch_p(const_edge e)370 can_remove_branch_p (const_edge e)
371 {
372 if (!cfg_hooks->can_remove_branch_p)
373 internal_error ("%s does not support can_remove_branch_p",
374 cfg_hooks->name);
375
376 if (EDGE_COUNT (e->src->succs) != 2)
377 return false;
378
379 return cfg_hooks->can_remove_branch_p (e);
380 }
381
382 /* Removes E, by redirecting it to the destination of the other edge going
383 from its source. Can_remove_branch_p must be true for E, hence this
384 operation cannot fail. */
385
386 void
remove_branch(edge e)387 remove_branch (edge e)
388 {
389 edge other;
390 basic_block src = e->src;
391 int irr;
392
393 gcc_assert (EDGE_COUNT (e->src->succs) == 2);
394
395 other = EDGE_SUCC (src, EDGE_SUCC (src, 0) == e);
396 irr = other->flags & EDGE_IRREDUCIBLE_LOOP;
397
398 e = redirect_edge_and_branch (e, other->dest);
399 gcc_assert (e != NULL);
400
401 e->flags &= ~EDGE_IRREDUCIBLE_LOOP;
402 e->flags |= irr;
403 }
404
405 /* Removes edge E from cfg. Unlike remove_branch, it does not update IL. */
406
407 void
remove_edge(edge e)408 remove_edge (edge e)
409 {
410 if (current_loops != NULL)
411 {
412 rescan_loop_exit (e, false, true);
413
414 /* Removal of an edge inside an irreducible region or which leads
415 to an irreducible region can turn the region into a natural loop.
416 In that case, ask for the loop structure fixups.
417
418 FIXME: Note that LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS is not always
419 set, so always ask for fixups when removing an edge in that case. */
420 if (!loops_state_satisfies_p (LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS)
421 || (e->flags & EDGE_IRREDUCIBLE_LOOP)
422 || (e->dest->flags & BB_IRREDUCIBLE_LOOP))
423 loops_state_set (LOOPS_NEED_FIXUP);
424 }
425
426 /* This is probably not needed, but it doesn't hurt. */
427 /* FIXME: This should be called via a remove_edge hook. */
428 if (current_ir_type () == IR_GIMPLE)
429 redirect_edge_var_map_clear (e);
430
431 remove_edge_raw (e);
432 }
433
434 /* Like redirect_edge_succ but avoid possible duplicate edge. */
435
436 edge
redirect_edge_succ_nodup(edge e,basic_block new_succ)437 redirect_edge_succ_nodup (edge e, basic_block new_succ)
438 {
439 edge s;
440
441 s = find_edge (e->src, new_succ);
442 if (s && s != e)
443 {
444 s->flags |= e->flags;
445 s->probability += e->probability;
446 if (s->probability > REG_BR_PROB_BASE)
447 s->probability = REG_BR_PROB_BASE;
448 s->count += e->count;
449 /* FIXME: This should be called via a hook and only for IR_GIMPLE. */
450 redirect_edge_var_map_dup (s, e);
451 remove_edge (e);
452 e = s;
453 }
454 else
455 redirect_edge_succ (e, new_succ);
456
457 return e;
458 }
459
460 /* Redirect the edge E to basic block DEST even if it requires creating
461 of a new basic block; then it returns the newly created basic block.
462 Aborts when redirection is impossible. */
463
464 basic_block
redirect_edge_and_branch_force(edge e,basic_block dest)465 redirect_edge_and_branch_force (edge e, basic_block dest)
466 {
467 basic_block ret, src = e->src;
468
469 if (!cfg_hooks->redirect_edge_and_branch_force)
470 internal_error ("%s does not support redirect_edge_and_branch_force",
471 cfg_hooks->name);
472
473 if (current_loops != NULL)
474 rescan_loop_exit (e, false, true);
475
476 ret = cfg_hooks->redirect_edge_and_branch_force (e, dest);
477
478 if (ret != NULL && dom_info_available_p (CDI_DOMINATORS))
479 set_immediate_dominator (CDI_DOMINATORS, ret, src);
480
481 if (current_loops != NULL)
482 {
483 if (ret != NULL)
484 {
485 struct loop *loop
486 = find_common_loop (single_pred (ret)->loop_father,
487 single_succ (ret)->loop_father);
488 add_bb_to_loop (ret, loop);
489 }
490 else if (find_edge (src, dest) == e)
491 rescan_loop_exit (e, true, false);
492 }
493
494 return ret;
495 }
496
497 /* Splits basic block BB after the specified instruction I (but at least after
498 the labels). If I is NULL, splits just after labels. The newly created edge
499 is returned. The new basic block is created just after the old one. */
500
501 static edge
split_block_1(basic_block bb,void * i)502 split_block_1 (basic_block bb, void *i)
503 {
504 basic_block new_bb;
505 edge res;
506
507 if (!cfg_hooks->split_block)
508 internal_error ("%s does not support split_block", cfg_hooks->name);
509
510 new_bb = cfg_hooks->split_block (bb, i);
511 if (!new_bb)
512 return NULL;
513
514 new_bb->count = bb->count;
515 new_bb->frequency = bb->frequency;
516 new_bb->discriminator = bb->discriminator;
517
518 if (dom_info_available_p (CDI_DOMINATORS))
519 {
520 redirect_immediate_dominators (CDI_DOMINATORS, bb, new_bb);
521 set_immediate_dominator (CDI_DOMINATORS, new_bb, bb);
522 }
523
524 if (current_loops != NULL)
525 {
526 edge_iterator ei;
527 edge e;
528 add_bb_to_loop (new_bb, bb->loop_father);
529 /* Identify all loops bb may have been the latch of and adjust them. */
530 FOR_EACH_EDGE (e, ei, new_bb->succs)
531 if (e->dest->loop_father->latch == bb)
532 e->dest->loop_father->latch = new_bb;
533 }
534
535 res = make_single_succ_edge (bb, new_bb, EDGE_FALLTHRU);
536
537 if (bb->flags & BB_IRREDUCIBLE_LOOP)
538 {
539 new_bb->flags |= BB_IRREDUCIBLE_LOOP;
540 res->flags |= EDGE_IRREDUCIBLE_LOOP;
541 }
542
543 return res;
544 }
545
546 edge
split_block(basic_block bb,gimple * i)547 split_block (basic_block bb, gimple *i)
548 {
549 return split_block_1 (bb, i);
550 }
551
552 edge
split_block(basic_block bb,rtx i)553 split_block (basic_block bb, rtx i)
554 {
555 return split_block_1 (bb, i);
556 }
557
558 /* Splits block BB just after labels. The newly created edge is returned. */
559
560 edge
split_block_after_labels(basic_block bb)561 split_block_after_labels (basic_block bb)
562 {
563 return split_block_1 (bb, NULL);
564 }
565
566 /* Moves block BB immediately after block AFTER. Returns false if the
567 movement was impossible. */
568
569 bool
move_block_after(basic_block bb,basic_block after)570 move_block_after (basic_block bb, basic_block after)
571 {
572 bool ret;
573
574 if (!cfg_hooks->move_block_after)
575 internal_error ("%s does not support move_block_after", cfg_hooks->name);
576
577 ret = cfg_hooks->move_block_after (bb, after);
578
579 return ret;
580 }
581
582 /* Deletes the basic block BB. */
583
584 void
delete_basic_block(basic_block bb)585 delete_basic_block (basic_block bb)
586 {
587 if (!cfg_hooks->delete_basic_block)
588 internal_error ("%s does not support delete_basic_block", cfg_hooks->name);
589
590 cfg_hooks->delete_basic_block (bb);
591
592 if (current_loops != NULL)
593 {
594 struct loop *loop = bb->loop_father;
595
596 /* If we remove the header or the latch of a loop, mark the loop for
597 removal. */
598 if (loop->latch == bb
599 || loop->header == bb)
600 mark_loop_for_removal (loop);
601
602 remove_bb_from_loops (bb);
603 }
604
605 /* Remove the edges into and out of this block. Note that there may
606 indeed be edges in, if we are removing an unreachable loop. */
607 while (EDGE_COUNT (bb->preds) != 0)
608 remove_edge (EDGE_PRED (bb, 0));
609 while (EDGE_COUNT (bb->succs) != 0)
610 remove_edge (EDGE_SUCC (bb, 0));
611
612 if (dom_info_available_p (CDI_DOMINATORS))
613 delete_from_dominance_info (CDI_DOMINATORS, bb);
614 if (dom_info_available_p (CDI_POST_DOMINATORS))
615 delete_from_dominance_info (CDI_POST_DOMINATORS, bb);
616
617 /* Remove the basic block from the array. */
618 expunge_block (bb);
619 }
620
621 /* Splits edge E and returns the newly created basic block. */
622
623 basic_block
split_edge(edge e)624 split_edge (edge e)
625 {
626 basic_block ret;
627 gcov_type count = e->count;
628 int freq = EDGE_FREQUENCY (e);
629 edge f;
630 bool irr = (e->flags & EDGE_IRREDUCIBLE_LOOP) != 0;
631 struct loop *loop;
632 basic_block src = e->src, dest = e->dest;
633
634 if (!cfg_hooks->split_edge)
635 internal_error ("%s does not support split_edge", cfg_hooks->name);
636
637 if (current_loops != NULL)
638 rescan_loop_exit (e, false, true);
639
640 ret = cfg_hooks->split_edge (e);
641 ret->count = count;
642 ret->frequency = freq;
643 single_succ_edge (ret)->probability = REG_BR_PROB_BASE;
644 single_succ_edge (ret)->count = count;
645
646 if (irr)
647 {
648 ret->flags |= BB_IRREDUCIBLE_LOOP;
649 single_pred_edge (ret)->flags |= EDGE_IRREDUCIBLE_LOOP;
650 single_succ_edge (ret)->flags |= EDGE_IRREDUCIBLE_LOOP;
651 }
652
653 if (dom_info_available_p (CDI_DOMINATORS))
654 set_immediate_dominator (CDI_DOMINATORS, ret, single_pred (ret));
655
656 if (dom_info_state (CDI_DOMINATORS) >= DOM_NO_FAST_QUERY)
657 {
658 /* There are two cases:
659
660 If the immediate dominator of e->dest is not e->src, it
661 remains unchanged.
662
663 If immediate dominator of e->dest is e->src, it may become
664 ret, provided that all other predecessors of e->dest are
665 dominated by e->dest. */
666
667 if (get_immediate_dominator (CDI_DOMINATORS, single_succ (ret))
668 == single_pred (ret))
669 {
670 edge_iterator ei;
671 FOR_EACH_EDGE (f, ei, single_succ (ret)->preds)
672 {
673 if (f == single_succ_edge (ret))
674 continue;
675
676 if (!dominated_by_p (CDI_DOMINATORS, f->src,
677 single_succ (ret)))
678 break;
679 }
680
681 if (!f)
682 set_immediate_dominator (CDI_DOMINATORS, single_succ (ret), ret);
683 }
684 }
685
686 if (current_loops != NULL)
687 {
688 loop = find_common_loop (src->loop_father, dest->loop_father);
689 add_bb_to_loop (ret, loop);
690
691 /* If we split the latch edge of loop adjust the latch block. */
692 if (loop->latch == src
693 && loop->header == dest)
694 loop->latch = ret;
695 }
696
697 return ret;
698 }
699
700 /* Creates a new basic block just after the basic block AFTER.
701 HEAD and END are the first and the last statement belonging
702 to the block. If both are NULL, an empty block is created. */
703
704 static basic_block
create_basic_block_1(void * head,void * end,basic_block after)705 create_basic_block_1 (void *head, void *end, basic_block after)
706 {
707 basic_block ret;
708
709 if (!cfg_hooks->create_basic_block)
710 internal_error ("%s does not support create_basic_block", cfg_hooks->name);
711
712 ret = cfg_hooks->create_basic_block (head, end, after);
713
714 if (dom_info_available_p (CDI_DOMINATORS))
715 add_to_dominance_info (CDI_DOMINATORS, ret);
716 if (dom_info_available_p (CDI_POST_DOMINATORS))
717 add_to_dominance_info (CDI_POST_DOMINATORS, ret);
718
719 return ret;
720 }
721
722 basic_block
create_basic_block(gimple_seq seq,basic_block after)723 create_basic_block (gimple_seq seq, basic_block after)
724 {
725 return create_basic_block_1 (seq, NULL, after);
726 }
727
728 basic_block
create_basic_block(rtx head,rtx end,basic_block after)729 create_basic_block (rtx head, rtx end, basic_block after)
730 {
731 return create_basic_block_1 (head, end, after);
732 }
733
734
735 /* Creates an empty basic block just after basic block AFTER. */
736
737 basic_block
create_empty_bb(basic_block after)738 create_empty_bb (basic_block after)
739 {
740 return create_basic_block_1 (NULL, NULL, after);
741 }
742
743 /* Checks whether we may merge blocks BB1 and BB2. */
744
745 bool
can_merge_blocks_p(basic_block bb1,basic_block bb2)746 can_merge_blocks_p (basic_block bb1, basic_block bb2)
747 {
748 bool ret;
749
750 if (!cfg_hooks->can_merge_blocks_p)
751 internal_error ("%s does not support can_merge_blocks_p", cfg_hooks->name);
752
753 ret = cfg_hooks->can_merge_blocks_p (bb1, bb2);
754
755 return ret;
756 }
757
758 void
predict_edge(edge e,enum br_predictor predictor,int probability)759 predict_edge (edge e, enum br_predictor predictor, int probability)
760 {
761 if (!cfg_hooks->predict_edge)
762 internal_error ("%s does not support predict_edge", cfg_hooks->name);
763
764 cfg_hooks->predict_edge (e, predictor, probability);
765 }
766
767 bool
predicted_by_p(const_basic_block bb,enum br_predictor predictor)768 predicted_by_p (const_basic_block bb, enum br_predictor predictor)
769 {
770 if (!cfg_hooks->predict_edge)
771 internal_error ("%s does not support predicted_by_p", cfg_hooks->name);
772
773 return cfg_hooks->predicted_by_p (bb, predictor);
774 }
775
776 /* Merges basic block B into basic block A. */
777
778 void
merge_blocks(basic_block a,basic_block b)779 merge_blocks (basic_block a, basic_block b)
780 {
781 edge e;
782 edge_iterator ei;
783
784 if (!cfg_hooks->merge_blocks)
785 internal_error ("%s does not support merge_blocks", cfg_hooks->name);
786
787 cfg_hooks->merge_blocks (a, b);
788
789 if (current_loops != NULL)
790 {
791 /* If the block we merge into is a loop header do nothing unless ... */
792 if (a->loop_father->header == a)
793 {
794 /* ... we merge two loop headers, in which case we kill
795 the inner loop. */
796 if (b->loop_father->header == b)
797 mark_loop_for_removal (b->loop_father);
798 }
799 /* If we merge a loop header into its predecessor, update the loop
800 structure. */
801 else if (b->loop_father->header == b)
802 {
803 remove_bb_from_loops (a);
804 add_bb_to_loop (a, b->loop_father);
805 a->loop_father->header = a;
806 }
807 /* If we merge a loop latch into its predecessor, update the loop
808 structure. */
809 if (b->loop_father->latch
810 && b->loop_father->latch == b)
811 b->loop_father->latch = a;
812 remove_bb_from_loops (b);
813 }
814
815 /* Normally there should only be one successor of A and that is B, but
816 partway though the merge of blocks for conditional_execution we'll
817 be merging a TEST block with THEN and ELSE successors. Free the
818 whole lot of them and hope the caller knows what they're doing. */
819
820 while (EDGE_COUNT (a->succs) != 0)
821 remove_edge (EDGE_SUCC (a, 0));
822
823 /* Adjust the edges out of B for the new owner. */
824 FOR_EACH_EDGE (e, ei, b->succs)
825 {
826 e->src = a;
827 if (current_loops != NULL)
828 {
829 /* If b was a latch, a now is. */
830 if (e->dest->loop_father->latch == b)
831 e->dest->loop_father->latch = a;
832 rescan_loop_exit (e, true, false);
833 }
834 }
835 a->succs = b->succs;
836 a->flags |= b->flags;
837
838 /* B hasn't quite yet ceased to exist. Attempt to prevent mishap. */
839 b->preds = b->succs = NULL;
840
841 if (dom_info_available_p (CDI_DOMINATORS))
842 redirect_immediate_dominators (CDI_DOMINATORS, b, a);
843
844 if (dom_info_available_p (CDI_DOMINATORS))
845 delete_from_dominance_info (CDI_DOMINATORS, b);
846 if (dom_info_available_p (CDI_POST_DOMINATORS))
847 delete_from_dominance_info (CDI_POST_DOMINATORS, b);
848
849 expunge_block (b);
850 }
851
852 /* Split BB into entry part and the rest (the rest is the newly created block).
853 Redirect those edges for that REDIRECT_EDGE_P returns true to the entry
854 part. Returns the edge connecting the entry part to the rest. */
855
856 edge
make_forwarder_block(basic_block bb,bool (* redirect_edge_p)(edge),void (* new_bb_cbk)(basic_block))857 make_forwarder_block (basic_block bb, bool (*redirect_edge_p) (edge),
858 void (*new_bb_cbk) (basic_block))
859 {
860 edge e, fallthru;
861 edge_iterator ei;
862 basic_block dummy, jump;
863 struct loop *loop, *ploop, *cloop;
864
865 if (!cfg_hooks->make_forwarder_block)
866 internal_error ("%s does not support make_forwarder_block",
867 cfg_hooks->name);
868
869 fallthru = split_block_after_labels (bb);
870 dummy = fallthru->src;
871 dummy->count = 0;
872 dummy->frequency = 0;
873 fallthru->count = 0;
874 bb = fallthru->dest;
875
876 /* Redirect back edges we want to keep. */
877 for (ei = ei_start (dummy->preds); (e = ei_safe_edge (ei)); )
878 {
879 basic_block e_src;
880
881 if (redirect_edge_p (e))
882 {
883 dummy->frequency += EDGE_FREQUENCY (e);
884 if (dummy->frequency > BB_FREQ_MAX)
885 dummy->frequency = BB_FREQ_MAX;
886
887 dummy->count += e->count;
888 fallthru->count += e->count;
889 ei_next (&ei);
890 continue;
891 }
892
893 e_src = e->src;
894 jump = redirect_edge_and_branch_force (e, bb);
895 if (jump != NULL)
896 {
897 /* If we redirected the loop latch edge, the JUMP block now acts like
898 the new latch of the loop. */
899 if (current_loops != NULL
900 && dummy->loop_father != NULL
901 && dummy->loop_father->header == dummy
902 && dummy->loop_father->latch == e_src)
903 dummy->loop_father->latch = jump;
904
905 if (new_bb_cbk != NULL)
906 new_bb_cbk (jump);
907 }
908 }
909
910 if (dom_info_available_p (CDI_DOMINATORS))
911 {
912 vec<basic_block> doms_to_fix;
913 doms_to_fix.create (2);
914 doms_to_fix.quick_push (dummy);
915 doms_to_fix.quick_push (bb);
916 iterate_fix_dominators (CDI_DOMINATORS, doms_to_fix, false);
917 doms_to_fix.release ();
918 }
919
920 if (current_loops != NULL)
921 {
922 /* If we do not split a loop header, then both blocks belong to the
923 same loop. In case we split loop header and do not redirect the
924 latch edge to DUMMY, then DUMMY belongs to the outer loop, and
925 BB becomes the new header. If latch is not recorded for the loop,
926 we leave this updating on the caller (this may only happen during
927 loop analysis). */
928 loop = dummy->loop_father;
929 if (loop->header == dummy
930 && loop->latch != NULL
931 && find_edge (loop->latch, dummy) == NULL)
932 {
933 remove_bb_from_loops (dummy);
934 loop->header = bb;
935
936 cloop = loop;
937 FOR_EACH_EDGE (e, ei, dummy->preds)
938 {
939 cloop = find_common_loop (cloop, e->src->loop_father);
940 }
941 add_bb_to_loop (dummy, cloop);
942 }
943
944 /* In case we split loop latch, update it. */
945 for (ploop = loop; ploop; ploop = loop_outer (ploop))
946 if (ploop->latch == dummy)
947 ploop->latch = bb;
948 }
949
950 cfg_hooks->make_forwarder_block (fallthru);
951
952 return fallthru;
953 }
954
955 /* Try to make the edge fallthru. */
956
957 void
tidy_fallthru_edge(edge e)958 tidy_fallthru_edge (edge e)
959 {
960 if (cfg_hooks->tidy_fallthru_edge)
961 cfg_hooks->tidy_fallthru_edge (e);
962 }
963
964 /* Fix up edges that now fall through, or rather should now fall through
965 but previously required a jump around now deleted blocks. Simplify
966 the search by only examining blocks numerically adjacent, since this
967 is how they were created.
968
969 ??? This routine is currently RTL specific. */
970
971 void
tidy_fallthru_edges(void)972 tidy_fallthru_edges (void)
973 {
974 basic_block b, c;
975
976 if (!cfg_hooks->tidy_fallthru_edge)
977 return;
978
979 if (ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb == EXIT_BLOCK_PTR_FOR_FN (cfun))
980 return;
981
982 FOR_BB_BETWEEN (b, ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb,
983 EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb, next_bb)
984 {
985 edge s;
986
987 c = b->next_bb;
988
989 /* We care about simple conditional or unconditional jumps with
990 a single successor.
991
992 If we had a conditional branch to the next instruction when
993 CFG was built, then there will only be one out edge for the
994 block which ended with the conditional branch (since we do
995 not create duplicate edges).
996
997 Furthermore, the edge will be marked as a fallthru because we
998 merge the flags for the duplicate edges. So we do not want to
999 check that the edge is not a FALLTHRU edge. */
1000
1001 if (single_succ_p (b))
1002 {
1003 s = single_succ_edge (b);
1004 if (! (s->flags & EDGE_COMPLEX)
1005 && s->dest == c
1006 && !(JUMP_P (BB_END (b)) && CROSSING_JUMP_P (BB_END (b))))
1007 tidy_fallthru_edge (s);
1008 }
1009 }
1010 }
1011
1012 /* Edge E is assumed to be fallthru edge. Emit needed jump instruction
1013 (and possibly create new basic block) to make edge non-fallthru.
1014 Return newly created BB or NULL if none. */
1015
1016 basic_block
force_nonfallthru(edge e)1017 force_nonfallthru (edge e)
1018 {
1019 basic_block ret, src = e->src;
1020
1021 if (!cfg_hooks->force_nonfallthru)
1022 internal_error ("%s does not support force_nonfallthru",
1023 cfg_hooks->name);
1024
1025 ret = cfg_hooks->force_nonfallthru (e);
1026 if (ret != NULL)
1027 {
1028 if (dom_info_available_p (CDI_DOMINATORS))
1029 set_immediate_dominator (CDI_DOMINATORS, ret, src);
1030
1031 if (current_loops != NULL)
1032 {
1033 struct loop *loop
1034 = find_common_loop (single_pred (ret)->loop_father,
1035 single_succ (ret)->loop_father);
1036 rescan_loop_exit (e, false, true);
1037 add_bb_to_loop (ret, loop);
1038 }
1039 }
1040
1041 return ret;
1042 }
1043
1044 /* Returns true if we can duplicate basic block BB. */
1045
1046 bool
can_duplicate_block_p(const_basic_block bb)1047 can_duplicate_block_p (const_basic_block bb)
1048 {
1049 if (!cfg_hooks->can_duplicate_block_p)
1050 internal_error ("%s does not support can_duplicate_block_p",
1051 cfg_hooks->name);
1052
1053 if (bb == EXIT_BLOCK_PTR_FOR_FN (cfun) || bb == ENTRY_BLOCK_PTR_FOR_FN (cfun))
1054 return false;
1055
1056 return cfg_hooks->can_duplicate_block_p (bb);
1057 }
1058
1059 /* Duplicates basic block BB and redirects edge E to it. Returns the
1060 new basic block. The new basic block is placed after the basic block
1061 AFTER. */
1062
1063 basic_block
duplicate_block(basic_block bb,edge e,basic_block after)1064 duplicate_block (basic_block bb, edge e, basic_block after)
1065 {
1066 edge s, n;
1067 basic_block new_bb;
1068 gcov_type new_count = e ? e->count : 0;
1069 edge_iterator ei;
1070
1071 if (!cfg_hooks->duplicate_block)
1072 internal_error ("%s does not support duplicate_block",
1073 cfg_hooks->name);
1074
1075 if (bb->count < new_count)
1076 new_count = bb->count;
1077
1078 gcc_checking_assert (can_duplicate_block_p (bb));
1079
1080 new_bb = cfg_hooks->duplicate_block (bb);
1081 if (after)
1082 move_block_after (new_bb, after);
1083
1084 new_bb->flags = bb->flags;
1085 FOR_EACH_EDGE (s, ei, bb->succs)
1086 {
1087 /* Since we are creating edges from a new block to successors
1088 of another block (which therefore are known to be disjoint), there
1089 is no need to actually check for duplicated edges. */
1090 n = unchecked_make_edge (new_bb, s->dest, s->flags);
1091 n->probability = s->probability;
1092 if (e && bb->count)
1093 {
1094 /* Take care for overflows! */
1095 n->count = s->count * (new_count * 10000 / bb->count) / 10000;
1096 s->count -= n->count;
1097 }
1098 else
1099 n->count = s->count;
1100 n->aux = s->aux;
1101 }
1102
1103 if (e)
1104 {
1105 new_bb->count = new_count;
1106 bb->count -= new_count;
1107
1108 new_bb->frequency = EDGE_FREQUENCY (e);
1109 bb->frequency -= EDGE_FREQUENCY (e);
1110
1111 redirect_edge_and_branch_force (e, new_bb);
1112
1113 if (bb->count < 0)
1114 bb->count = 0;
1115 if (bb->frequency < 0)
1116 bb->frequency = 0;
1117 }
1118 else
1119 {
1120 new_bb->count = bb->count;
1121 new_bb->frequency = bb->frequency;
1122 }
1123
1124 set_bb_original (new_bb, bb);
1125 set_bb_copy (bb, new_bb);
1126
1127 /* Add the new block to the copy of the loop of BB, or directly to the loop
1128 of BB if the loop is not being copied. */
1129 if (current_loops != NULL)
1130 {
1131 struct loop *cloop = bb->loop_father;
1132 struct loop *copy = get_loop_copy (cloop);
1133 /* If we copied the loop header block but not the loop
1134 we have created a loop with multiple entries. Ditch the loop,
1135 add the new block to the outer loop and arrange for a fixup. */
1136 if (!copy
1137 && cloop->header == bb)
1138 {
1139 add_bb_to_loop (new_bb, loop_outer (cloop));
1140 mark_loop_for_removal (cloop);
1141 }
1142 else
1143 {
1144 add_bb_to_loop (new_bb, copy ? copy : cloop);
1145 /* If we copied the loop latch block but not the loop, adjust
1146 loop state. */
1147 if (!copy
1148 && cloop->latch == bb)
1149 {
1150 cloop->latch = NULL;
1151 loops_state_set (LOOPS_MAY_HAVE_MULTIPLE_LATCHES);
1152 }
1153 }
1154 }
1155
1156 return new_bb;
1157 }
1158
1159 /* Return 1 if BB ends with a call, possibly followed by some
1160 instructions that must stay with the call, 0 otherwise. */
1161
1162 bool
block_ends_with_call_p(basic_block bb)1163 block_ends_with_call_p (basic_block bb)
1164 {
1165 if (!cfg_hooks->block_ends_with_call_p)
1166 internal_error ("%s does not support block_ends_with_call_p", cfg_hooks->name);
1167
1168 return (cfg_hooks->block_ends_with_call_p) (bb);
1169 }
1170
1171 /* Return 1 if BB ends with a conditional branch, 0 otherwise. */
1172
1173 bool
block_ends_with_condjump_p(const_basic_block bb)1174 block_ends_with_condjump_p (const_basic_block bb)
1175 {
1176 if (!cfg_hooks->block_ends_with_condjump_p)
1177 internal_error ("%s does not support block_ends_with_condjump_p",
1178 cfg_hooks->name);
1179
1180 return (cfg_hooks->block_ends_with_condjump_p) (bb);
1181 }
1182
1183 /* Add fake edges to the function exit for any non constant and non noreturn
1184 calls, volatile inline assembly in the bitmap of blocks specified by
1185 BLOCKS or to the whole CFG if BLOCKS is zero. Return the number of blocks
1186 that were split.
1187
1188 The goal is to expose cases in which entering a basic block does not imply
1189 that all subsequent instructions must be executed. */
1190
1191 int
flow_call_edges_add(sbitmap blocks)1192 flow_call_edges_add (sbitmap blocks)
1193 {
1194 if (!cfg_hooks->flow_call_edges_add)
1195 internal_error ("%s does not support flow_call_edges_add",
1196 cfg_hooks->name);
1197
1198 return (cfg_hooks->flow_call_edges_add) (blocks);
1199 }
1200
1201 /* This function is called immediately after edge E is added to the
1202 edge vector E->dest->preds. */
1203
1204 void
execute_on_growing_pred(edge e)1205 execute_on_growing_pred (edge e)
1206 {
1207 if (cfg_hooks->execute_on_growing_pred)
1208 cfg_hooks->execute_on_growing_pred (e);
1209 }
1210
1211 /* This function is called immediately before edge E is removed from
1212 the edge vector E->dest->preds. */
1213
1214 void
execute_on_shrinking_pred(edge e)1215 execute_on_shrinking_pred (edge e)
1216 {
1217 if (cfg_hooks->execute_on_shrinking_pred)
1218 cfg_hooks->execute_on_shrinking_pred (e);
1219 }
1220
1221 /* This is used inside loop versioning when we want to insert
1222 stmts/insns on the edges, which have a different behavior
1223 in tree's and in RTL, so we made a CFG hook. */
1224 void
lv_flush_pending_stmts(edge e)1225 lv_flush_pending_stmts (edge e)
1226 {
1227 if (cfg_hooks->flush_pending_stmts)
1228 cfg_hooks->flush_pending_stmts (e);
1229 }
1230
1231 /* Loop versioning uses the duplicate_loop_to_header_edge to create
1232 a new version of the loop basic-blocks, the parameters here are
1233 exactly the same as in duplicate_loop_to_header_edge or
1234 tree_duplicate_loop_to_header_edge; while in tree-ssa there is
1235 additional work to maintain ssa information that's why there is
1236 a need to call the tree_duplicate_loop_to_header_edge rather
1237 than duplicate_loop_to_header_edge when we are in tree mode. */
1238 bool
cfg_hook_duplicate_loop_to_header_edge(struct loop * loop,edge e,unsigned int ndupl,sbitmap wont_exit,edge orig,vec<edge> * to_remove,int flags)1239 cfg_hook_duplicate_loop_to_header_edge (struct loop *loop, edge e,
1240 unsigned int ndupl,
1241 sbitmap wont_exit, edge orig,
1242 vec<edge> *to_remove,
1243 int flags)
1244 {
1245 gcc_assert (cfg_hooks->cfg_hook_duplicate_loop_to_header_edge);
1246 return cfg_hooks->cfg_hook_duplicate_loop_to_header_edge (loop, e,
1247 ndupl, wont_exit,
1248 orig, to_remove,
1249 flags);
1250 }
1251
1252 /* Conditional jumps are represented differently in trees and RTL,
1253 this hook takes a basic block that is known to have a cond jump
1254 at its end and extracts the taken and not taken edges out of it
1255 and store it in E1 and E2 respectively. */
1256 void
extract_cond_bb_edges(basic_block b,edge * e1,edge * e2)1257 extract_cond_bb_edges (basic_block b, edge *e1, edge *e2)
1258 {
1259 gcc_assert (cfg_hooks->extract_cond_bb_edges);
1260 cfg_hooks->extract_cond_bb_edges (b, e1, e2);
1261 }
1262
1263 /* Responsible for updating the ssa info (PHI nodes) on the
1264 new condition basic block that guards the versioned loop. */
1265 void
lv_adjust_loop_header_phi(basic_block first,basic_block second,basic_block new_block,edge e)1266 lv_adjust_loop_header_phi (basic_block first, basic_block second,
1267 basic_block new_block, edge e)
1268 {
1269 if (cfg_hooks->lv_adjust_loop_header_phi)
1270 cfg_hooks->lv_adjust_loop_header_phi (first, second, new_block, e);
1271 }
1272
1273 /* Conditions in trees and RTL are different so we need
1274 a different handling when we add the condition to the
1275 versioning code. */
1276 void
lv_add_condition_to_bb(basic_block first,basic_block second,basic_block new_block,void * cond)1277 lv_add_condition_to_bb (basic_block first, basic_block second,
1278 basic_block new_block, void *cond)
1279 {
1280 gcc_assert (cfg_hooks->lv_add_condition_to_bb);
1281 cfg_hooks->lv_add_condition_to_bb (first, second, new_block, cond);
1282 }
1283
1284 /* Checks whether all N blocks in BBS array can be copied. */
1285 bool
can_copy_bbs_p(basic_block * bbs,unsigned n)1286 can_copy_bbs_p (basic_block *bbs, unsigned n)
1287 {
1288 unsigned i;
1289 edge e;
1290 int ret = true;
1291
1292 for (i = 0; i < n; i++)
1293 bbs[i]->flags |= BB_DUPLICATED;
1294
1295 for (i = 0; i < n; i++)
1296 {
1297 /* In case we should redirect abnormal edge during duplication, fail. */
1298 edge_iterator ei;
1299 FOR_EACH_EDGE (e, ei, bbs[i]->succs)
1300 if ((e->flags & EDGE_ABNORMAL)
1301 && (e->dest->flags & BB_DUPLICATED))
1302 {
1303 ret = false;
1304 goto end;
1305 }
1306
1307 if (!can_duplicate_block_p (bbs[i]))
1308 {
1309 ret = false;
1310 break;
1311 }
1312 }
1313
1314 end:
1315 for (i = 0; i < n; i++)
1316 bbs[i]->flags &= ~BB_DUPLICATED;
1317
1318 return ret;
1319 }
1320
1321 /* Duplicates N basic blocks stored in array BBS. Newly created basic blocks
1322 are placed into array NEW_BBS in the same order. Edges from basic blocks
1323 in BBS are also duplicated and copies of those that lead into BBS are
1324 redirected to appropriate newly created block. The function assigns bbs
1325 into loops (copy of basic block bb is assigned to bb->loop_father->copy
1326 loop, so this must be set up correctly in advance)
1327
1328 If UPDATE_DOMINANCE is true then this function updates dominators locally
1329 (LOOPS structure that contains the information about dominators is passed
1330 to enable this), otherwise it does not update the dominator information
1331 and it assumed that the caller will do this, perhaps by destroying and
1332 recreating it instead of trying to do an incremental update like this
1333 function does when update_dominance is true.
1334
1335 BASE is the superloop to that basic block belongs; if its header or latch
1336 is copied, we do not set the new blocks as header or latch.
1337
1338 Created copies of N_EDGES edges in array EDGES are stored in array NEW_EDGES,
1339 also in the same order.
1340
1341 Newly created basic blocks are put after the basic block AFTER in the
1342 instruction stream, and the order of the blocks in BBS array is preserved. */
1343
1344 void
copy_bbs(basic_block * bbs,unsigned n,basic_block * new_bbs,edge * edges,unsigned num_edges,edge * new_edges,struct loop * base,basic_block after,bool update_dominance)1345 copy_bbs (basic_block *bbs, unsigned n, basic_block *new_bbs,
1346 edge *edges, unsigned num_edges, edge *new_edges,
1347 struct loop *base, basic_block after, bool update_dominance)
1348 {
1349 unsigned i, j;
1350 basic_block bb, new_bb, dom_bb;
1351 edge e;
1352
1353 /* Duplicate bbs, update dominators, assign bbs to loops. */
1354 for (i = 0; i < n; i++)
1355 {
1356 /* Duplicate. */
1357 bb = bbs[i];
1358 new_bb = new_bbs[i] = duplicate_block (bb, NULL, after);
1359 after = new_bb;
1360 bb->flags |= BB_DUPLICATED;
1361 if (bb->loop_father)
1362 {
1363 /* Possibly set loop header. */
1364 if (bb->loop_father->header == bb && bb->loop_father != base)
1365 new_bb->loop_father->header = new_bb;
1366 /* Or latch. */
1367 if (bb->loop_father->latch == bb && bb->loop_father != base)
1368 new_bb->loop_father->latch = new_bb;
1369 }
1370 }
1371
1372 /* Set dominators. */
1373 if (update_dominance)
1374 {
1375 for (i = 0; i < n; i++)
1376 {
1377 bb = bbs[i];
1378 new_bb = new_bbs[i];
1379
1380 dom_bb = get_immediate_dominator (CDI_DOMINATORS, bb);
1381 if (dom_bb->flags & BB_DUPLICATED)
1382 {
1383 dom_bb = get_bb_copy (dom_bb);
1384 set_immediate_dominator (CDI_DOMINATORS, new_bb, dom_bb);
1385 }
1386 }
1387 }
1388
1389 /* Redirect edges. */
1390 for (j = 0; j < num_edges; j++)
1391 new_edges[j] = NULL;
1392 for (i = 0; i < n; i++)
1393 {
1394 edge_iterator ei;
1395 new_bb = new_bbs[i];
1396 bb = bbs[i];
1397
1398 FOR_EACH_EDGE (e, ei, new_bb->succs)
1399 {
1400 for (j = 0; j < num_edges; j++)
1401 if (edges[j] && edges[j]->src == bb && edges[j]->dest == e->dest)
1402 new_edges[j] = e;
1403
1404 if (!(e->dest->flags & BB_DUPLICATED))
1405 continue;
1406 redirect_edge_and_branch_force (e, get_bb_copy (e->dest));
1407 }
1408 }
1409
1410 /* Clear information about duplicates. */
1411 for (i = 0; i < n; i++)
1412 bbs[i]->flags &= ~BB_DUPLICATED;
1413 }
1414
1415 /* Return true if BB contains only labels or non-executable
1416 instructions */
1417 bool
empty_block_p(basic_block bb)1418 empty_block_p (basic_block bb)
1419 {
1420 gcc_assert (cfg_hooks->empty_block_p);
1421 return cfg_hooks->empty_block_p (bb);
1422 }
1423
1424 /* Split a basic block if it ends with a conditional branch and if
1425 the other part of the block is not empty. */
1426 basic_block
split_block_before_cond_jump(basic_block bb)1427 split_block_before_cond_jump (basic_block bb)
1428 {
1429 gcc_assert (cfg_hooks->split_block_before_cond_jump);
1430 return cfg_hooks->split_block_before_cond_jump (bb);
1431 }
1432
1433 /* Work-horse for passes.c:check_profile_consistency.
1434 Do book-keeping of the CFG for the profile consistency checker.
1435 If AFTER_PASS is 0, do pre-pass accounting, or if AFTER_PASS is 1
1436 then do post-pass accounting. Store the counting in RECORD. */
1437
1438 void
account_profile_record(struct profile_record * record,int after_pass)1439 account_profile_record (struct profile_record *record, int after_pass)
1440 {
1441 basic_block bb;
1442 edge_iterator ei;
1443 edge e;
1444 int sum;
1445 gcov_type lsum;
1446
1447 FOR_ALL_BB_FN (bb, cfun)
1448 {
1449 if (bb != EXIT_BLOCK_PTR_FOR_FN (cfun)
1450 && profile_status_for_fn (cfun) != PROFILE_ABSENT)
1451 {
1452 sum = 0;
1453 FOR_EACH_EDGE (e, ei, bb->succs)
1454 sum += e->probability;
1455 if (EDGE_COUNT (bb->succs) && abs (sum - REG_BR_PROB_BASE) > 100)
1456 record->num_mismatched_freq_out[after_pass]++;
1457 lsum = 0;
1458 FOR_EACH_EDGE (e, ei, bb->succs)
1459 lsum += e->count;
1460 if (EDGE_COUNT (bb->succs)
1461 && (lsum - bb->count > 100 || lsum - bb->count < -100))
1462 record->num_mismatched_count_out[after_pass]++;
1463 }
1464 if (bb != ENTRY_BLOCK_PTR_FOR_FN (cfun)
1465 && profile_status_for_fn (cfun) != PROFILE_ABSENT)
1466 {
1467 sum = 0;
1468 FOR_EACH_EDGE (e, ei, bb->preds)
1469 sum += EDGE_FREQUENCY (e);
1470 if (abs (sum - bb->frequency) > 100
1471 || (MAX (sum, bb->frequency) > 10
1472 && abs ((sum - bb->frequency) * 100 / (MAX (sum, bb->frequency) + 1)) > 10))
1473 record->num_mismatched_freq_in[after_pass]++;
1474 lsum = 0;
1475 FOR_EACH_EDGE (e, ei, bb->preds)
1476 lsum += e->count;
1477 if (lsum - bb->count > 100 || lsum - bb->count < -100)
1478 record->num_mismatched_count_in[after_pass]++;
1479 }
1480 if (bb == ENTRY_BLOCK_PTR_FOR_FN (cfun)
1481 || bb == EXIT_BLOCK_PTR_FOR_FN (cfun))
1482 continue;
1483 gcc_assert (cfg_hooks->account_profile_record);
1484 cfg_hooks->account_profile_record (bb, after_pass, record);
1485 }
1486 }
1487