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