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