contrib/gcc-5.0/gcc/cfghooks.c

   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
   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 "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.  */
  56 static struct cfg_hooks *cfg_hooks;
  57
  58 /* Initialization of functions specific to the rtl IR.  */
  59 void
  60 rtl_register_cfg_hooks (void)
  61 {
  62   cfg_hooks = &rtl_cfg_hooks;
  63 }
  64
  65 /* Initialization of functions specific to the rtl IR.  */
  66 void
  67 cfg_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
  74 void
  75 gimple_register_cfg_hooks (void)
  76 {
  77   cfg_hooks = &gimple_cfg_hooks;
  78 }
  79
  80 struct cfg_hooks
  81 get_cfg_hooks (void)
  82 {
  83   return *cfg_hooks;
  84 }
  85
  86 void
  87 set_cfg_hooks (struct cfg_hooks new_cfg_hooks)
  88 {
  89   *cfg_hooks = new_cfg_hooks;
  90 }
  91
  92 /* Returns current ir type.  */
  93
  94 enum ir_type
  95 current_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
 112 DEBUG_FUNCTION void
 113 verify_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
 291 void
 292 dump_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
 303 DEBUG_FUNCTION void
 304 debug (basic_block_def &ref)
 305 {
 306   dump_bb (stderr, &ref, 0, 0);
 307 }
 308
 309 DEBUG_FUNCTION void
 310 debug (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
 326 void
 327 dump_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.  */
 341 void
 342 dump_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.  */
 355 void debug_flow_info (void);
 356 DEBUG_FUNCTION void
 357 debug_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
 367 edge
 368 redirect_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
 389 bool
 390 can_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
 406 void
 407 remove_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
 427 void
 428 remove_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
 443 edge
 444 redirect_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
 471 basic_block
 472 redirect_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
 508 edge
 509 split_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
 555 edge
 556 split_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
 564 bool
 565 move_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
 579 void
 580 delete_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
 618 basic_block
 619 split_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
 699 basic_block
 700 create_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
 719 basic_block
 720 create_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
 727 bool
 728 can_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
 740 void
 741 predict_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
 749 bool
 750 predicted_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
 760 void
 761 merge_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
 838 edge
 839 make_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           dummy->count += e->count;
 867           fallthru->count += e->count;
 868           ei_next (&ei);
 869           continue;
 870         }
 871
 872       e_src = e->src;
 873       jump = redirect_edge_and_branch_force (e, bb);
 874       if (jump != NULL)
 875         {
 876           /* If we redirected the loop latch edge, the JUMP block now acts like
 877              the new latch of the loop.  */
 878           if (current_loops != NULL
 879               && dummy->loop_father != NULL
 880               && dummy->loop_father->header == dummy
 881               && dummy->loop_father->latch == e_src)
 882             dummy->loop_father->latch = jump;
 883
 884           if (new_bb_cbk != NULL)
 885             new_bb_cbk (jump);
 886         }
 887     }
 888
 889   if (dom_info_available_p (CDI_DOMINATORS))
 890     {
 891       vec<basic_block> doms_to_fix;
 892       doms_to_fix.create (2);
 893       doms_to_fix.quick_push (dummy);
 894       doms_to_fix.quick_push (bb);
 895       iterate_fix_dominators (CDI_DOMINATORS, doms_to_fix, false);
 896       doms_to_fix.release ();
 897     }
 898
 899   if (current_loops != NULL)
 900     {
 901       /* If we do not split a loop header, then both blocks belong to the
 902          same loop.  In case we split loop header and do not redirect the
 903          latch edge to DUMMY, then DUMMY belongs to the outer loop, and
 904          BB becomes the new header.  If latch is not recorded for the loop,
 905          we leave this updating on the caller (this may only happen during
 906          loop analysis).  */
 907       loop = dummy->loop_father;
 908       if (loop->header == dummy
 909           && loop->latch != NULL
 910           && find_edge (loop->latch, dummy) == NULL)
 911         {
 912           remove_bb_from_loops (dummy);
 913           loop->header = bb;
 914
 915           cloop = loop;
 916           FOR_EACH_EDGE (e, ei, dummy->preds)
 917             {
 918               cloop = find_common_loop (cloop, e->src->loop_father);
 919             }
 920           add_bb_to_loop (dummy, cloop);
 921         }
 922
 923       /* In case we split loop latch, update it.  */
 924       for (ploop = loop; ploop; ploop = loop_outer (ploop))
 925         if (ploop->latch == dummy)
 926           ploop->latch = bb;
 927     }
 928
 929   cfg_hooks->make_forwarder_block (fallthru);
 930
 931   return fallthru;
 932 }
 933
 934 /* Try to make the edge fallthru.  */
 935
 936 void
 937 tidy_fallthru_edge (edge e)
 938 {
 939   if (cfg_hooks->tidy_fallthru_edge)
 940     cfg_hooks->tidy_fallthru_edge (e);
 941 }
 942
 943 /* Fix up edges that now fall through, or rather should now fall through
 944    but previously required a jump around now deleted blocks.  Simplify
 945    the search by only examining blocks numerically adjacent, since this
 946    is how they were created.
 947
 948    ??? This routine is currently RTL specific.  */
 949
 950 void
 951 tidy_fallthru_edges (void)
 952 {
 953   basic_block b, c;
 954
 955   if (!cfg_hooks->tidy_fallthru_edge)
 956     return;
 957
 958   if (ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb == EXIT_BLOCK_PTR_FOR_FN (cfun))
 959     return;
 960
 961   FOR_BB_BETWEEN (b, ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb,
 962                   EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb, next_bb)
 963     {
 964       edge s;
 965
 966       c = b->next_bb;
 967
 968       /* We care about simple conditional or unconditional jumps with
 969          a single successor.
 970
 971          If we had a conditional branch to the next instruction when
 972          CFG was built, then there will only be one out edge for the
 973          block which ended with the conditional branch (since we do
 974          not create duplicate edges).
 975
 976          Furthermore, the edge will be marked as a fallthru because we
 977          merge the flags for the duplicate edges.  So we do not want to
 978          check that the edge is not a FALLTHRU edge.  */
 979
 980       if (single_succ_p (b))
 981         {
 982           s = single_succ_edge (b);
 983           if (! (s->flags & EDGE_COMPLEX)
 984               && s->dest == c
 985               && !(JUMP_P (BB_END (b)) && CROSSING_JUMP_P (BB_END (b))))
 986             tidy_fallthru_edge (s);
 987         }
 988     }
 989 }
 990
 991 /* Edge E is assumed to be fallthru edge.  Emit needed jump instruction
 992    (and possibly create new basic block) to make edge non-fallthru.
 993    Return newly created BB or NULL if none.  */
 994
 995 basic_block
 996 force_nonfallthru (edge e)
 997 {
 998   basic_block ret, src = e->src;
 999
1000   if (!cfg_hooks->force_nonfallthru)
1001     internal_error ("%s does not support force_nonfallthru",
1002                     cfg_hooks->name);
1003
1004   ret = cfg_hooks->force_nonfallthru (e);
1005   if (ret != NULL)
1006     {
1007       if (dom_info_available_p (CDI_DOMINATORS))
1008         set_immediate_dominator (CDI_DOMINATORS, ret, src);
1009
1010       if (current_loops != NULL)
1011         {
1012           struct loop *loop
1013             = find_common_loop (single_pred (ret)->loop_father,
1014                                 single_succ (ret)->loop_father);
1015           rescan_loop_exit (e, false, true);
1016           add_bb_to_loop (ret, loop);
1017         }
1018     }
1019
1020   return ret;
1021 }
1022
1023 /* Returns true if we can duplicate basic block BB.  */
1024
1025 bool
1026 can_duplicate_block_p (const_basic_block bb)
1027 {
1028   if (!cfg_hooks->can_duplicate_block_p)
1029     internal_error ("%s does not support can_duplicate_block_p",
1030                     cfg_hooks->name);
1031
1032   if (bb == EXIT_BLOCK_PTR_FOR_FN (cfun) || bb == ENTRY_BLOCK_PTR_FOR_FN (cfun))
1033     return false;
1034
1035   return cfg_hooks->can_duplicate_block_p (bb);
1036 }
1037
1038 /* Duplicates basic block BB and redirects edge E to it.  Returns the
1039    new basic block.  The new basic block is placed after the basic block
1040    AFTER.  */
1041
1042 basic_block
1043 duplicate_block (basic_block bb, edge e, basic_block after)
1044 {
1045   edge s, n;
1046   basic_block new_bb;
1047   gcov_type new_count = e ? e->count : 0;
1048   edge_iterator ei;
1049
1050   if (!cfg_hooks->duplicate_block)
1051     internal_error ("%s does not support duplicate_block",
1052                     cfg_hooks->name);
1053
1054   if (bb->count < new_count)
1055     new_count = bb->count;
1056
1057   gcc_checking_assert (can_duplicate_block_p (bb));
1058
1059   new_bb = cfg_hooks->duplicate_block (bb);
1060   if (after)
1061     move_block_after (new_bb, after);
1062
1063   new_bb->flags = bb->flags;
1064   FOR_EACH_EDGE (s, ei, bb->succs)
1065     {
1066       /* Since we are creating edges from a new block to successors
1067          of another block (which therefore are known to be disjoint), there
1068          is no need to actually check for duplicated edges.  */
1069       n = unchecked_make_edge (new_bb, s->dest, s->flags);
1070       n->probability = s->probability;
1071       if (e && bb->count)
1072         {
1073           /* Take care for overflows!  */
1074           n->count = s->count * (new_count * 10000 / bb->count) / 10000;
1075           s->count -= n->count;
1076         }
1077       else
1078         n->count = s->count;
1079       n->aux = s->aux;
1080     }
1081
1082   if (e)
1083     {
1084       new_bb->count = new_count;
1085       bb->count -= new_count;
1086
1087       new_bb->frequency = EDGE_FREQUENCY (e);
1088       bb->frequency -= EDGE_FREQUENCY (e);
1089
1090       redirect_edge_and_branch_force (e, new_bb);
1091
1092       if (bb->count < 0)
1093         bb->count = 0;
1094       if (bb->frequency < 0)
1095         bb->frequency = 0;
1096     }
1097   else
1098     {
1099       new_bb->count = bb->count;
1100       new_bb->frequency = bb->frequency;
1101     }
1102
1103   set_bb_original (new_bb, bb);
1104   set_bb_copy (bb, new_bb);
1105
1106   /* Add the new block to the copy of the loop of BB, or directly to the loop
1107      of BB if the loop is not being copied.  */
1108   if (current_loops != NULL)
1109     {
1110       struct loop *cloop = bb->loop_father;
1111       struct loop *copy = get_loop_copy (cloop);
1112       /* If we copied the loop header block but not the loop
1113          we have created a loop with multiple entries.  Ditch the loop,
1114          add the new block to the outer loop and arrange for a fixup.  */
1115       if (!copy
1116           && cloop->header == bb)
1117         {
1118           add_bb_to_loop (new_bb, loop_outer (cloop));
1119           mark_loop_for_removal (cloop);
1120         }
1121       else
1122         {
1123           add_bb_to_loop (new_bb, copy ? copy : cloop);
1124           /* If we copied the loop latch block but not the loop, adjust
1125              loop state.  */
1126           if (!copy
1127               && cloop->latch == bb)
1128             {
1129               cloop->latch = NULL;
1130               loops_state_set (LOOPS_MAY_HAVE_MULTIPLE_LATCHES);
1131             }
1132         }
1133     }
1134
1135   return new_bb;
1136 }
1137
1138 /* Return 1 if BB ends with a call, possibly followed by some
1139    instructions that must stay with the call, 0 otherwise.  */
1140
1141 bool
1142 block_ends_with_call_p (basic_block bb)
1143 {
1144   if (!cfg_hooks->block_ends_with_call_p)
1145     internal_error ("%s does not support block_ends_with_call_p", cfg_hooks->name);
1146
1147   return (cfg_hooks->block_ends_with_call_p) (bb);
1148 }
1149
1150 /* Return 1 if BB ends with a conditional branch, 0 otherwise.  */
1151
1152 bool
1153 block_ends_with_condjump_p (const_basic_block bb)
1154 {
1155   if (!cfg_hooks->block_ends_with_condjump_p)
1156     internal_error ("%s does not support block_ends_with_condjump_p",
1157                     cfg_hooks->name);
1158
1159   return (cfg_hooks->block_ends_with_condjump_p) (bb);
1160 }
1161
1162 /* Add fake edges to the function exit for any non constant and non noreturn
1163    calls, volatile inline assembly in the bitmap of blocks specified by
1164    BLOCKS or to the whole CFG if BLOCKS is zero.  Return the number of blocks
1165    that were split.
1166
1167    The goal is to expose cases in which entering a basic block does not imply
1168    that all subsequent instructions must be executed.  */
1169
1170 int
1171 flow_call_edges_add (sbitmap blocks)
1172 {
1173   if (!cfg_hooks->flow_call_edges_add)
1174     internal_error ("%s does not support flow_call_edges_add",
1175                     cfg_hooks->name);
1176
1177   return (cfg_hooks->flow_call_edges_add) (blocks);
1178 }
1179
1180 /* This function is called immediately after edge E is added to the
1181    edge vector E->dest->preds.  */
1182
1183 void
1184 execute_on_growing_pred (edge e)
1185 {
1186   if (cfg_hooks->execute_on_growing_pred)
1187     cfg_hooks->execute_on_growing_pred (e);
1188 }
1189
1190 /* This function is called immediately before edge E is removed from
1191    the edge vector E->dest->preds.  */
1192
1193 void
1194 execute_on_shrinking_pred (edge e)
1195 {
1196   if (cfg_hooks->execute_on_shrinking_pred)
1197     cfg_hooks->execute_on_shrinking_pred (e);
1198 }
1199
1200 /* This is used inside loop versioning when we want to insert
1201    stmts/insns on the edges, which have a different behavior
1202    in tree's and in RTL, so we made a CFG hook.  */
1203 void
1204 lv_flush_pending_stmts (edge e)
1205 {
1206   if (cfg_hooks->flush_pending_stmts)
1207     cfg_hooks->flush_pending_stmts (e);
1208 }
1209
1210 /* Loop versioning uses the duplicate_loop_to_header_edge to create
1211    a new version of the loop basic-blocks, the parameters here are
1212    exactly the same as in duplicate_loop_to_header_edge or
1213    tree_duplicate_loop_to_header_edge; while in tree-ssa there is
1214    additional work to maintain ssa information that's why there is
1215    a need to call the tree_duplicate_loop_to_header_edge rather
1216    than duplicate_loop_to_header_edge when we are in tree mode.  */
1217 bool
1218 cfg_hook_duplicate_loop_to_header_edge (struct loop *loop, edge e,
1219                                         unsigned int ndupl,
1220                                         sbitmap wont_exit, edge orig,
1221                                         vec<edge> *to_remove,
1222                                         int flags)
1223 {
1224   gcc_assert (cfg_hooks->cfg_hook_duplicate_loop_to_header_edge);
1225   return cfg_hooks->cfg_hook_duplicate_loop_to_header_edge (loop, e,
1226                                                             ndupl, wont_exit,
1227                                                             orig, to_remove,
1228                                                             flags);
1229 }
1230
1231 /* Conditional jumps are represented differently in trees and RTL,
1232    this hook takes a basic block that is known to have a cond jump
1233    at its end and extracts the taken and not taken edges out of it
1234    and store it in E1 and E2 respectively.  */
1235 void
1236 extract_cond_bb_edges (basic_block b, edge *e1, edge *e2)
1237 {
1238   gcc_assert (cfg_hooks->extract_cond_bb_edges);
1239   cfg_hooks->extract_cond_bb_edges (b, e1, e2);
1240 }
1241
1242 /* Responsible for updating the ssa info (PHI nodes) on the
1243    new condition basic block that guards the versioned loop.  */
1244 void
1245 lv_adjust_loop_header_phi (basic_block first, basic_block second,
1246                            basic_block new_block, edge e)
1247 {
1248   if (cfg_hooks->lv_adjust_loop_header_phi)
1249     cfg_hooks->lv_adjust_loop_header_phi (first, second, new_block, e);
1250 }
1251
1252 /* Conditions in trees and RTL are different so we need
1253    a different handling when we add the condition to the
1254    versioning code.  */
1255 void
1256 lv_add_condition_to_bb (basic_block first, basic_block second,
1257                         basic_block new_block, void *cond)
1258 {
1259   gcc_assert (cfg_hooks->lv_add_condition_to_bb);
1260   cfg_hooks->lv_add_condition_to_bb (first, second, new_block, cond);
1261 }
1262
1263 /* Checks whether all N blocks in BBS array can be copied.  */
1264 bool
1265 can_copy_bbs_p (basic_block *bbs, unsigned n)
1266 {
1267   unsigned i;
1268   edge e;
1269   int ret = true;
1270
1271   for (i = 0; i < n; i++)
1272     bbs[i]->flags |= BB_DUPLICATED;
1273
1274   for (i = 0; i < n; i++)
1275     {
1276       /* In case we should redirect abnormal edge during duplication, fail.  */
1277       edge_iterator ei;
1278       FOR_EACH_EDGE (e, ei, bbs[i]->succs)
1279         if ((e->flags & EDGE_ABNORMAL)
1280             && (e->dest->flags & BB_DUPLICATED))
1281           {
1282             ret = false;
1283             goto end;
1284           }
1285
1286       if (!can_duplicate_block_p (bbs[i]))
1287         {
1288           ret = false;
1289           break;
1290         }
1291     }
1292
1293 end:
1294   for (i = 0; i < n; i++)
1295     bbs[i]->flags &= ~BB_DUPLICATED;
1296
1297   return ret;
1298 }
1299
1300 /* Duplicates N basic blocks stored in array BBS.  Newly created basic blocks
1301    are placed into array NEW_BBS in the same order.  Edges from basic blocks
1302    in BBS are also duplicated and copies of those that lead into BBS are
1303    redirected to appropriate newly created block.  The function assigns bbs
1304    into loops (copy of basic block bb is assigned to bb->loop_father->copy
1305    loop, so this must be set up correctly in advance)
1306
1307    If UPDATE_DOMINANCE is true then this function updates dominators locally
1308    (LOOPS structure that contains the information about dominators is passed
1309    to enable this), otherwise it does not update the dominator information
1310    and it assumed that the caller will do this, perhaps by destroying and
1311    recreating it instead of trying to do an incremental update like this
1312    function does when update_dominance is true.
1313
1314    BASE is the superloop to that basic block belongs; if its header or latch
1315    is copied, we do not set the new blocks as header or latch.
1316
1317    Created copies of N_EDGES edges in array EDGES are stored in array NEW_EDGES,
1318    also in the same order.
1319
1320    Newly created basic blocks are put after the basic block AFTER in the
1321    instruction stream, and the order of the blocks in BBS array is preserved.  */
1322
1323 void
1324 copy_bbs (basic_block *bbs, unsigned n, basic_block *new_bbs,
1325           edge *edges, unsigned num_edges, edge *new_edges,
1326           struct loop *base, basic_block after, bool update_dominance)
1327 {
1328   unsigned i, j;
1329   basic_block bb, new_bb, dom_bb;
1330   edge e;
1331
1332   /* Duplicate bbs, update dominators, assign bbs to loops.  */
1333   for (i = 0; i < n; i++)
1334     {
1335       /* Duplicate.  */
1336       bb = bbs[i];
1337       new_bb = new_bbs[i] = duplicate_block (bb, NULL, after);
1338       after = new_bb;
1339       bb->flags |= BB_DUPLICATED;
1340       if (bb->loop_father)
1341         {
1342           /* Possibly set loop header.  */
1343           if (bb->loop_father->header == bb && bb->loop_father != base)
1344             new_bb->loop_father->header = new_bb;
1345           /* Or latch.  */
1346           if (bb->loop_father->latch == bb && bb->loop_father != base)
1347             new_bb->loop_father->latch = new_bb;
1348         }
1349     }
1350
1351   /* Set dominators.  */
1352   if (update_dominance)
1353     {
1354       for (i = 0; i < n; i++)
1355         {
1356           bb = bbs[i];
1357           new_bb = new_bbs[i];
1358
1359           dom_bb = get_immediate_dominator (CDI_DOMINATORS, bb);
1360           if (dom_bb->flags & BB_DUPLICATED)
1361             {
1362               dom_bb = get_bb_copy (dom_bb);
1363               set_immediate_dominator (CDI_DOMINATORS, new_bb, dom_bb);
1364             }
1365         }
1366     }
1367
1368   /* Redirect edges.  */
1369   for (j = 0; j < num_edges; j++)
1370     new_edges[j] = NULL;
1371   for (i = 0; i < n; i++)
1372     {
1373       edge_iterator ei;
1374       new_bb = new_bbs[i];
1375       bb = bbs[i];
1376
1377       FOR_EACH_EDGE (e, ei, new_bb->succs)
1378         {
1379           for (j = 0; j < num_edges; j++)
1380             if (edges[j] && edges[j]->src == bb && edges[j]->dest == e->dest)
1381               new_edges[j] = e;
1382
1383           if (!(e->dest->flags & BB_DUPLICATED))
1384             continue;
1385           redirect_edge_and_branch_force (e, get_bb_copy (e->dest));
1386         }
1387     }
1388
1389   /* Clear information about duplicates.  */
1390   for (i = 0; i < n; i++)
1391     bbs[i]->flags &= ~BB_DUPLICATED;
1392 }
1393
1394 /* Return true if BB contains only labels or non-executable
1395    instructions */
1396 bool
1397 empty_block_p (basic_block bb)
1398 {
1399   gcc_assert (cfg_hooks->empty_block_p);
1400   return cfg_hooks->empty_block_p (bb);
1401 }
1402
1403 /* Split a basic block if it ends with a conditional branch and if
1404    the other part of the block is not empty.  */
1405 basic_block
1406 split_block_before_cond_jump (basic_block bb)
1407 {
1408   gcc_assert (cfg_hooks->split_block_before_cond_jump);
1409   return cfg_hooks->split_block_before_cond_jump (bb);
1410 }
1411
1412 /* Work-horse for passes.c:check_profile_consistency.
1413    Do book-keeping of the CFG for the profile consistency checker.
1414    If AFTER_PASS is 0, do pre-pass accounting, or if AFTER_PASS is 1
1415    then do post-pass accounting.  Store the counting in RECORD.  */
1416
1417 void
1418 account_profile_record (struct profile_record *record, int after_pass)
1419 {
1420   basic_block bb;
1421   edge_iterator ei;
1422   edge e;
1423   int sum;
1424   gcov_type lsum;
1425
1426   FOR_ALL_BB_FN (bb, cfun)
1427    {
1428       if (bb != EXIT_BLOCK_PTR_FOR_FN (cfun)
1429           && profile_status_for_fn (cfun) != PROFILE_ABSENT)
1430         {
1431           sum = 0;
1432           FOR_EACH_EDGE (e, ei, bb->succs)
1433             sum += e->probability;
1434           if (EDGE_COUNT (bb->succs) && abs (sum - REG_BR_PROB_BASE) > 100)
1435             record->num_mismatched_freq_out[after_pass]++;
1436           lsum = 0;
1437           FOR_EACH_EDGE (e, ei, bb->succs)
1438             lsum += e->count;
1439           if (EDGE_COUNT (bb->succs)
1440               && (lsum - bb->count > 100 || lsum - bb->count < -100))
1441             record->num_mismatched_count_out[after_pass]++;
1442         }
1443       if (bb != ENTRY_BLOCK_PTR_FOR_FN (cfun)
1444           && profile_status_for_fn (cfun) != PROFILE_ABSENT)
1445         {
1446           sum = 0;
1447           FOR_EACH_EDGE (e, ei, bb->preds)
1448             sum += EDGE_FREQUENCY (e);
1449           if (abs (sum - bb->frequency) > 100
1450               || (MAX (sum, bb->frequency) > 10
1451                   && abs ((sum - bb->frequency) * 100 / (MAX (sum, bb->frequency) + 1)) > 10))
1452             record->num_mismatched_freq_in[after_pass]++;
1453           lsum = 0;
1454           FOR_EACH_EDGE (e, ei, bb->preds)
1455             lsum += e->count;
1456           if (lsum - bb->count > 100 || lsum - bb->count < -100)
1457             record->num_mismatched_count_in[after_pass]++;
1458         }
1459       if (bb == ENTRY_BLOCK_PTR_FOR_FN (cfun)
1460           || bb == EXIT_BLOCK_PTR_FOR_FN (cfun))
1461         continue;
1462       gcc_assert (cfg_hooks->account_profile_record);
1463       cfg_hooks->account_profile_record (bb, after_pass, record);
1464    }
1465 }