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