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

source code of gcc/cfghooks.cc