gcc/cfglayout.c

   1 /* Basic block reordering routines for the GNU compiler.
   2    Copyright (C) 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 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 "tm.h"
  25 #include "tree.h"
  26 #include "rtl.h"
  27 #include "hard-reg-set.h"
  28 #include "obstack.h"
  29 #include "basic-block.h"
  30 #include "insn-config.h"
  31 #include "output.h"
  32 #include "function.h"
  33 #include "cfglayout.h"
  34 #include "cfgloop.h"
  35 #include "target.h"
  36 #include "ggc.h"
  37 #include "alloc-pool.h"
  38 #include "flags.h"
  39 #include "tree-pass.h"
  40 #include "df.h"
  41 #include "vecprim.h"
  42
  43 /* Holds the interesting trailing notes for the function.  */
  44 rtx cfg_layout_function_footer;
  45 rtx cfg_layout_function_header;
  46
  47 static rtx skip_insns_after_block (basic_block);
  48 static void record_effective_endpoints (void);
  49 static rtx label_for_bb (basic_block);
  50 static void fixup_reorder_chain (void);
  51
  52 static void change_scope (rtx, tree, tree);
  53
  54 void verify_insn_chain (void);
  55 static void fixup_fallthru_exit_predecessor (void);
  56 static tree insn_scope (const_rtx);
  57 \f
  58 rtx
  59 unlink_insn_chain (rtx first, rtx last)
  60 {
  61   rtx prevfirst = PREV_INSN (first);
  62   rtx nextlast = NEXT_INSN (last);
  63
  64   PREV_INSN (first) = NULL;
  65   NEXT_INSN (last) = NULL;
  66   if (prevfirst)
  67     NEXT_INSN (prevfirst) = nextlast;
  68   if (nextlast)
  69     PREV_INSN (nextlast) = prevfirst;
  70   else
  71     set_last_insn (prevfirst);
  72   if (!prevfirst)
  73     set_first_insn (nextlast);
  74   return first;
  75 }
  76 \f
  77 /* Skip over inter-block insns occurring after BB which are typically
  78    associated with BB (e.g., barriers). If there are any such insns,
  79    we return the last one. Otherwise, we return the end of BB.  */
  80
  81 static rtx
  82 skip_insns_after_block (basic_block bb)
  83 {
  84   rtx insn, last_insn, next_head, prev;
  85
  86   next_head = NULL_RTX;
  87   if (bb->next_bb != EXIT_BLOCK_PTR)
  88     next_head = BB_HEAD (bb->next_bb);
  89
  90   for (last_insn = insn = BB_END (bb); (insn = NEXT_INSN (insn)) != 0; )
  91     {
  92       if (insn == next_head)
  93         break;
  94
  95       switch (GET_CODE (insn))
  96         {
  97         case BARRIER:
  98           last_insn = insn;
  99           continue;
 100
 101         case NOTE:
 102           switch (NOTE_KIND (insn))
 103             {
 104             case NOTE_INSN_BLOCK_END:
 105               gcc_unreachable ();
 106               continue;
 107             default:
 108               continue;
 109               break;
 110             }
 111           break;
 112
 113         case CODE_LABEL:
 114           if (NEXT_INSN (insn)
 115               && JUMP_P (NEXT_INSN (insn))
 116               && (GET_CODE (PATTERN (NEXT_INSN (insn))) == ADDR_VEC
 117                   || GET_CODE (PATTERN (NEXT_INSN (insn))) == ADDR_DIFF_VEC))
 118             {
 119               insn = NEXT_INSN (insn);
 120               last_insn = insn;
 121               continue;
 122             }
 123           break;
 124
 125         default:
 126           break;
 127         }
 128
 129       break;
 130     }
 131
 132   /* It is possible to hit contradictory sequence.  For instance:
 133
 134      jump_insn
 135      NOTE_INSN_BLOCK_BEG
 136      barrier
 137
 138      Where barrier belongs to jump_insn, but the note does not.  This can be
 139      created by removing the basic block originally following
 140      NOTE_INSN_BLOCK_BEG.  In such case reorder the notes.  */
 141
 142   for (insn = last_insn; insn != BB_END (bb); insn = prev)
 143     {
 144       prev = PREV_INSN (insn);
 145       if (NOTE_P (insn))
 146         switch (NOTE_KIND (insn))
 147           {
 148           case NOTE_INSN_BLOCK_END:
 149             gcc_unreachable ();
 150             break;
 151           case NOTE_INSN_DELETED:
 152           case NOTE_INSN_DELETED_LABEL:
 153             continue;
 154           default:
 155             reorder_insns (insn, insn, last_insn);
 156           }
 157     }
 158
 159   return last_insn;
 160 }
 161
 162 /* Locate or create a label for a given basic block.  */
 163
 164 static rtx
 165 label_for_bb (basic_block bb)
 166 {
 167   rtx label = BB_HEAD (bb);
 168
 169   if (!LABEL_P (label))
 170     {
 171       if (dump_file)
 172         fprintf (dump_file, "Emitting label for block %d\n", bb->index);
 173
 174       label = block_label (bb);
 175     }
 176
 177   return label;
 178 }
 179
 180 /* Locate the effective beginning and end of the insn chain for each
 181    block, as defined by skip_insns_after_block above.  */
 182
 183 static void
 184 record_effective_endpoints (void)
 185 {
 186   rtx next_insn;
 187   basic_block bb;
 188   rtx insn;
 189
 190   for (insn = get_insns ();
 191        insn
 192        && NOTE_P (insn)
 193        && NOTE_KIND (insn) != NOTE_INSN_BASIC_BLOCK;
 194        insn = NEXT_INSN (insn))
 195     continue;
 196   /* No basic blocks at all?  */
 197   gcc_assert (insn);
 198
 199   if (PREV_INSN (insn))
 200     cfg_layout_function_header =
 201             unlink_insn_chain (get_insns (), PREV_INSN (insn));
 202   else
 203     cfg_layout_function_header = NULL_RTX;
 204
 205   next_insn = get_insns ();
 206   FOR_EACH_BB (bb)
 207     {
 208       rtx end;
 209
 210       if (PREV_INSN (BB_HEAD (bb)) && next_insn != BB_HEAD (bb))
 211         bb->il.rtl->header = unlink_insn_chain (next_insn,
 212                                               PREV_INSN (BB_HEAD (bb)));
 213       end = skip_insns_after_block (bb);
 214       if (NEXT_INSN (BB_END (bb)) && BB_END (bb) != end)
 215         bb->il.rtl->footer = unlink_insn_chain (NEXT_INSN (BB_END (bb)), end);
 216       next_insn = NEXT_INSN (BB_END (bb));
 217     }
 218
 219   cfg_layout_function_footer = next_insn;
 220   if (cfg_layout_function_footer)
 221     cfg_layout_function_footer = unlink_insn_chain (cfg_layout_function_footer, get_last_insn ());
 222 }
 223 \f
 224 /* Data structures representing mapping of INSN_LOCATOR into scope blocks, line
 225    numbers and files.  In order to be GGC friendly we need to use separate
 226    varrays.  This also slightly improve the memory locality in binary search.
 227    The _locs array contains locators where the given property change.  The
 228    block_locators_blocks contains the scope block that is used for all insn
 229    locator greater than corresponding block_locators_locs value and smaller
 230    than the following one.  Similarly for the other properties.  */
 231 static VEC(int,heap) *block_locators_locs;
 232 static GTY(()) VEC(tree,gc) *block_locators_blocks;
 233 static VEC(int,heap) *locations_locators_locs;
 234 DEF_VEC_O(location_t);
 235 DEF_VEC_ALLOC_O(location_t,heap);
 236 static VEC(location_t,heap) *locations_locators_vals;
 237 int prologue_locator;
 238 int epilogue_locator;
 239
 240 /* Hold current location information and last location information, so the
 241    datastructures are built lazily only when some instructions in given
 242    place are needed.  */
 243 location_t curr_location, last_location;
 244 static tree curr_block, last_block;
 245 static int curr_rtl_loc = -1;
 246
 247 /* Allocate insn locator datastructure.  */
 248 void
 249 insn_locators_alloc (void)
 250 {
 251   prologue_locator = epilogue_locator = 0;
 252
 253   block_locators_locs = VEC_alloc (int, heap, 32);
 254   block_locators_blocks = VEC_alloc (tree, gc, 32);
 255   locations_locators_locs = VEC_alloc (int, heap, 32);
 256   locations_locators_vals = VEC_alloc (location_t, heap, 32);
 257
 258   last_location = -1;
 259   curr_location = -1;
 260   curr_block = NULL;
 261   last_block = NULL;
 262   curr_rtl_loc = 0;
 263 }
 264
 265 /* At the end of emit stage, clear current location.  */
 266 void
 267 insn_locators_finalize (void)
 268 {
 269   if (curr_rtl_loc >= 0)
 270     epilogue_locator = curr_insn_locator ();
 271   curr_rtl_loc = -1;
 272 }
 273
 274 /* Allocate insn locator datastructure.  */
 275 void
 276 insn_locators_free (void)
 277 {
 278   prologue_locator = epilogue_locator = 0;
 279
 280   VEC_free (int, heap, block_locators_locs);
 281   VEC_free (tree,gc, block_locators_blocks);
 282   VEC_free (int, heap, locations_locators_locs);
 283   VEC_free (location_t, heap, locations_locators_vals);
 284 }
 285
 286
 287 /* Set current location.  */
 288 void
 289 set_curr_insn_source_location (location_t location)
 290 {
 291   /* IV opts calls into RTL expansion to compute costs of operations.  At this
 292      time locators are not initialized.  */
 293   if (curr_rtl_loc == -1)
 294     return;
 295   if (location == last_location)
 296     return;
 297   curr_location = location;
 298 }
 299
 300 /* Set current scope block. */
 301 void
 302 set_curr_insn_block (tree b)
 303 {
 304   /* IV opts calls into RTL expansion to compute costs of operations.  At this
 305      time locators are not initialized.  */
 306   if (curr_rtl_loc == -1)
 307     return;
 308   if (b)
 309     curr_block = b;
 310 }
 311
 312 /* Return current insn locator.  */
 313 int
 314 curr_insn_locator (void)
 315 {
 316   if (curr_rtl_loc == -1)
 317     return 0;
 318   if (last_block != curr_block)
 319     {
 320       curr_rtl_loc++;
 321       VEC_safe_push (int, heap, block_locators_locs, curr_rtl_loc);
 322       VEC_safe_push (tree, gc, block_locators_blocks, curr_block);
 323       last_block = curr_block;
 324     }
 325   if (last_location != curr_location)
 326     {
 327       curr_rtl_loc++;
 328       VEC_safe_push (int, heap, locations_locators_locs, curr_rtl_loc);
 329       VEC_safe_push (location_t, heap, locations_locators_vals, &curr_location);
 330       last_location = curr_location;
 331     }
 332   return curr_rtl_loc;
 333 }
 334
 335 static unsigned int
 336 into_cfg_layout_mode (void)
 337 {
 338   cfg_layout_initialize (0);
 339   return 0;
 340 }
 341
 342 static unsigned int
 343 outof_cfg_layout_mode (void)
 344 {
 345   basic_block bb;
 346
 347   FOR_EACH_BB (bb)
 348     if (bb->next_bb != EXIT_BLOCK_PTR)
 349       bb->aux = bb->next_bb;
 350
 351   cfg_layout_finalize ();
 352
 353   return 0;
 354 }
 355
 356 struct rtl_opt_pass pass_into_cfg_layout_mode =
 357 {
 358  {
 359   RTL_PASS,
 360   "into_cfglayout",                     /* name */
 361   NULL,                                 /* gate */
 362   into_cfg_layout_mode,                 /* execute */
 363   NULL,                                 /* sub */
 364   NULL,                                 /* next */
 365   0,                                    /* static_pass_number */
 366   TV_NONE,                              /* tv_id */
 367   0,                                    /* properties_required */
 368   PROP_cfglayout,                       /* properties_provided */
 369   0,                                    /* properties_destroyed */
 370   0,                                    /* todo_flags_start */
 371   TODO_dump_func,                       /* todo_flags_finish */
 372  }
 373 };
 374
 375 struct rtl_opt_pass pass_outof_cfg_layout_mode =
 376 {
 377  {
 378   RTL_PASS,
 379   "outof_cfglayout",                    /* name */
 380   NULL,                                 /* gate */
 381   outof_cfg_layout_mode,                /* execute */
 382   NULL,                                 /* sub */
 383   NULL,                                 /* next */
 384   0,                                    /* static_pass_number */
 385   TV_NONE,                              /* tv_id */
 386   0,                                    /* properties_required */
 387   0,                                    /* properties_provided */
 388   PROP_cfglayout,                       /* properties_destroyed */
 389   0,                                    /* todo_flags_start */
 390   TODO_dump_func,                       /* todo_flags_finish */
 391  }
 392 };
 393 \f
 394 /* Return scope resulting from combination of S1 and S2.  */
 395 static tree
 396 choose_inner_scope (tree s1, tree s2)
 397 {
 398    if (!s1)
 399      return s2;
 400    if (!s2)
 401      return s1;
 402    if (BLOCK_NUMBER (s1) > BLOCK_NUMBER (s2))
 403      return s1;
 404    return s2;
 405 }
 406 \f
 407 /* Emit lexical block notes needed to change scope from S1 to S2.  */
 408
 409 static void
 410 change_scope (rtx orig_insn, tree s1, tree s2)
 411 {
 412   rtx insn = orig_insn;
 413   tree com = NULL_TREE;
 414   tree ts1 = s1, ts2 = s2;
 415   tree s;
 416
 417   while (ts1 != ts2)
 418     {
 419       gcc_assert (ts1 && ts2);
 420       if (BLOCK_NUMBER (ts1) > BLOCK_NUMBER (ts2))
 421         ts1 = BLOCK_SUPERCONTEXT (ts1);
 422       else if (BLOCK_NUMBER (ts1) < BLOCK_NUMBER (ts2))
 423         ts2 = BLOCK_SUPERCONTEXT (ts2);
 424       else
 425         {
 426           ts1 = BLOCK_SUPERCONTEXT (ts1);
 427           ts2 = BLOCK_SUPERCONTEXT (ts2);
 428         }
 429     }
 430   com = ts1;
 431
 432   /* Close scopes.  */
 433   s = s1;
 434   while (s != com)
 435     {
 436       rtx note = emit_note_before (NOTE_INSN_BLOCK_END, insn);
 437       NOTE_BLOCK (note) = s;
 438       s = BLOCK_SUPERCONTEXT (s);
 439     }
 440
 441   /* Open scopes.  */
 442   s = s2;
 443   while (s != com)
 444     {
 445       insn = emit_note_before (NOTE_INSN_BLOCK_BEG, insn);
 446       NOTE_BLOCK (insn) = s;
 447       s = BLOCK_SUPERCONTEXT (s);
 448     }
 449 }
 450
 451 /* Return lexical scope block locator belongs to.  */
 452 static tree
 453 locator_scope (int loc)
 454 {
 455   int max = VEC_length (int, block_locators_locs);
 456   int min = 0;
 457
 458   /* When block_locators_locs was initialized, the pro- and epilogue
 459      insns didn't exist yet and can therefore not be found this way.
 460      But we know that they belong to the outer most block of the
 461      current function.
 462      Without this test, the prologue would be put inside the block of
 463      the first valid instruction in the function and when that first
 464      insn is part of an inlined function then the low_pc of that
 465      inlined function is messed up.  Likewise for the epilogue and
 466      the last valid instruction.  */
 467   if (loc == prologue_locator || loc == epilogue_locator)
 468     return DECL_INITIAL (cfun->decl);
 469
 470   if (!max || !loc)
 471     return NULL;
 472   while (1)
 473     {
 474       int pos = (min + max) / 2;
 475       int tmp = VEC_index (int, block_locators_locs, pos);
 476
 477       if (tmp <= loc && min != pos)
 478         min = pos;
 479       else if (tmp > loc && max != pos)
 480         max = pos;
 481       else
 482         {
 483           min = pos;
 484           break;
 485         }
 486     }
 487   return VEC_index (tree, block_locators_blocks, min);
 488 }
 489
 490 /* Return lexical scope block insn belongs to.  */
 491 static tree
 492 insn_scope (const_rtx insn)
 493 {
 494   return locator_scope (INSN_LOCATOR (insn));
 495 }
 496
 497 /* Return line number of the statement specified by the locator.  */
 498 location_t
 499 locator_location (int loc)
 500 {
 501   int max = VEC_length (int, locations_locators_locs);
 502   int min = 0;
 503
 504   while (1)
 505     {
 506       int pos = (min + max) / 2;
 507       int tmp = VEC_index (int, locations_locators_locs, pos);
 508
 509       if (tmp <= loc && min != pos)
 510         min = pos;
 511       else if (tmp > loc && max != pos)
 512         max = pos;
 513       else
 514         {
 515           min = pos;
 516           break;
 517         }
 518     }
 519   return *VEC_index (location_t, locations_locators_vals, min);
 520 }
 521
 522 /* Return source line of the statement that produced this insn.  */
 523 int
 524 locator_line (int loc)
 525 {
 526   expanded_location xloc;
 527   if (!loc)
 528     return 0;
 529   else
 530     xloc = expand_location (locator_location (loc));
 531   return xloc.line;
 532 }
 533
 534 /* Return line number of the statement that produced this insn.  */
 535 int
 536 insn_line (const_rtx insn)
 537 {
 538   return locator_line (INSN_LOCATOR (insn));
 539 }
 540
 541 /* Return source file of the statement specified by LOC.  */
 542 const char *
 543 locator_file (int loc)
 544 {
 545   expanded_location xloc;
 546   if (!loc)
 547     return 0;
 548   else
 549     xloc = expand_location (locator_location (loc));
 550   return xloc.file;
 551 }
 552
 553 /* Return source file of the statement that produced this insn.  */
 554 const char *
 555 insn_file (const_rtx insn)
 556 {
 557   return locator_file (INSN_LOCATOR (insn));
 558 }
 559
 560 /* Return true if LOC1 and LOC2 locators have the same location and scope.  */
 561 bool
 562 locator_eq (int loc1, int loc2)
 563 {
 564   if (loc1 == loc2)
 565     return true;
 566   if (locator_location (loc1) != locator_location (loc2))
 567     return false;
 568   return locator_scope (loc1) == locator_scope (loc2);
 569 }
 570
 571 /* Rebuild all the NOTE_INSN_BLOCK_BEG and NOTE_INSN_BLOCK_END notes based
 572    on the scope tree and the newly reordered instructions.  */
 573
 574 void
 575 reemit_insn_block_notes (void)
 576 {
 577   tree cur_block = DECL_INITIAL (cfun->decl);
 578   rtx insn, note;
 579
 580   insn = get_insns ();
 581   if (!active_insn_p (insn))
 582     insn = next_active_insn (insn);
 583   for (; insn; insn = next_active_insn (insn))
 584     {
 585       tree this_block;
 586
 587       /* Avoid putting scope notes between jump table and its label.  */
 588       if (JUMP_P (insn)
 589           && (GET_CODE (PATTERN (insn)) == ADDR_VEC
 590               || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC))
 591         continue;
 592
 593       this_block = insn_scope (insn);
 594       /* For sequences compute scope resulting from merging all scopes
 595          of instructions nested inside.  */
 596       if (GET_CODE (PATTERN (insn)) == SEQUENCE)
 597         {
 598           int i;
 599           rtx body = PATTERN (insn);
 600
 601           this_block = NULL;
 602           for (i = 0; i < XVECLEN (body, 0); i++)
 603             this_block = choose_inner_scope (this_block,
 604                                          insn_scope (XVECEXP (body, 0, i)));
 605         }
 606       if (! this_block)
 607         continue;
 608
 609       if (this_block != cur_block)
 610         {
 611           change_scope (insn, cur_block, this_block);
 612           cur_block = this_block;
 613         }
 614     }
 615
 616   /* change_scope emits before the insn, not after.  */
 617   note = emit_note (NOTE_INSN_DELETED);
 618   change_scope (note, cur_block, DECL_INITIAL (cfun->decl));
 619   delete_insn (note);
 620
 621   reorder_blocks ();
 622 }
 623 \f
 624
 625 /* Link the basic blocks in the correct order, compacting the basic
 626    block queue while at it.  This also clears the visited flag on
 627    all basic blocks.  If STAY_IN_CFGLAYOUT_MODE is false, this function
 628    also clears the basic block header and footer fields.
 629
 630    This function is usually called after a pass (e.g. tracer) finishes
 631    some transformations while in cfglayout mode.  The required sequence
 632    of the basic blocks is in a linked list along the bb->aux field.
 633    This functions re-links the basic block prev_bb and next_bb pointers
 634    accordingly, and it compacts and renumbers the blocks.  */
 635
 636 void
 637 relink_block_chain (bool stay_in_cfglayout_mode)
 638 {
 639   basic_block bb, prev_bb;
 640   int index;
 641
 642   /* Maybe dump the re-ordered sequence.  */
 643   if (dump_file)
 644     {
 645       fprintf (dump_file, "Reordered sequence:\n");
 646       for (bb = ENTRY_BLOCK_PTR->next_bb, index = NUM_FIXED_BLOCKS;
 647            bb;
 648            bb = (basic_block) bb->aux, index++)
 649         {
 650           fprintf (dump_file, " %i ", index);
 651           if (get_bb_original (bb))
 652             fprintf (dump_file, "duplicate of %i ",
 653                      get_bb_original (bb)->index);
 654           else if (forwarder_block_p (bb)
 655                    && !LABEL_P (BB_HEAD (bb)))
 656             fprintf (dump_file, "compensation ");
 657           else
 658             fprintf (dump_file, "bb %i ", bb->index);
 659           fprintf (dump_file, " [%i]\n", bb->frequency);
 660         }
 661     }
 662
 663   /* Now reorder the blocks.  */
 664   prev_bb = ENTRY_BLOCK_PTR;
 665   bb = ENTRY_BLOCK_PTR->next_bb;
 666   for (; bb; prev_bb = bb, bb = (basic_block) bb->aux)
 667     {
 668       bb->prev_bb = prev_bb;
 669       prev_bb->next_bb = bb;
 670     }
 671   prev_bb->next_bb = EXIT_BLOCK_PTR;
 672   EXIT_BLOCK_PTR->prev_bb = prev_bb;
 673
 674   /* Then, clean up the aux and visited fields.  */
 675   FOR_ALL_BB (bb)
 676     {
 677       bb->aux = NULL;
 678       bb->il.rtl->visited = 0;
 679       if (!stay_in_cfglayout_mode)
 680         bb->il.rtl->header = bb->il.rtl->footer = NULL;
 681     }
 682
 683   /* Maybe reset the original copy tables, they are not valid anymore
 684      when we renumber the basic blocks in compact_blocks.  If we are
 685      are going out of cfglayout mode, don't re-allocate the tables.  */
 686   free_original_copy_tables ();
 687   if (stay_in_cfglayout_mode)
 688     initialize_original_copy_tables ();
 689
 690   /* Finally, put basic_block_info in the new order.  */
 691   compact_blocks ();
 692 }
 693 \f
 694
 695 /* Given a reorder chain, rearrange the code to match.  */
 696
 697 static void
 698 fixup_reorder_chain (void)
 699 {
 700   basic_block bb;
 701   rtx insn = NULL;
 702
 703   if (cfg_layout_function_header)
 704     {
 705       set_first_insn (cfg_layout_function_header);
 706       insn = cfg_layout_function_header;
 707       while (NEXT_INSN (insn))
 708         insn = NEXT_INSN (insn);
 709     }
 710
 711   /* First do the bulk reordering -- rechain the blocks without regard to
 712      the needed changes to jumps and labels.  */
 713
 714   for (bb = ENTRY_BLOCK_PTR->next_bb; bb; bb = (basic_block) bb->aux)
 715     {
 716       if (bb->il.rtl->header)
 717         {
 718           if (insn)
 719             NEXT_INSN (insn) = bb->il.rtl->header;
 720           else
 721             set_first_insn (bb->il.rtl->header);
 722           PREV_INSN (bb->il.rtl->header) = insn;
 723           insn = bb->il.rtl->header;
 724           while (NEXT_INSN (insn))
 725             insn = NEXT_INSN (insn);
 726         }
 727       if (insn)
 728         NEXT_INSN (insn) = BB_HEAD (bb);
 729       else
 730         set_first_insn (BB_HEAD (bb));
 731       PREV_INSN (BB_HEAD (bb)) = insn;
 732       insn = BB_END (bb);
 733       if (bb->il.rtl->footer)
 734         {
 735           NEXT_INSN (insn) = bb->il.rtl->footer;
 736           PREV_INSN (bb->il.rtl->footer) = insn;
 737           while (NEXT_INSN (insn))
 738             insn = NEXT_INSN (insn);
 739         }
 740     }
 741
 742   NEXT_INSN (insn) = cfg_layout_function_footer;
 743   if (cfg_layout_function_footer)
 744     PREV_INSN (cfg_layout_function_footer) = insn;
 745
 746   while (NEXT_INSN (insn))
 747     insn = NEXT_INSN (insn);
 748
 749   set_last_insn (insn);
 750 #ifdef ENABLE_CHECKING
 751   verify_insn_chain ();
 752 #endif
 753
 754   /* Now add jumps and labels as needed to match the blocks new
 755      outgoing edges.  */
 756
 757   for (bb = ENTRY_BLOCK_PTR->next_bb; bb ; bb = (basic_block) bb->aux)
 758     {
 759       edge e_fall, e_taken, e;
 760       rtx bb_end_insn;
 761       basic_block nb;
 762       edge_iterator ei;
 763
 764       if (EDGE_COUNT (bb->succs) == 0)
 765         continue;
 766
 767       /* Find the old fallthru edge, and another non-EH edge for
 768          a taken jump.  */
 769       e_taken = e_fall = NULL;
 770
 771       FOR_EACH_EDGE (e, ei, bb->succs)
 772         if (e->flags & EDGE_FALLTHRU)
 773           e_fall = e;
 774         else if (! (e->flags & EDGE_EH))
 775           e_taken = e;
 776
 777       bb_end_insn = BB_END (bb);
 778       if (JUMP_P (bb_end_insn))
 779         {
 780           if (any_condjump_p (bb_end_insn))
 781             {
 782               /* If the old fallthru is still next, nothing to do.  */
 783               if (bb->aux == e_fall->dest
 784                   || e_fall->dest == EXIT_BLOCK_PTR)
 785                 continue;
 786
 787               /* The degenerated case of conditional jump jumping to the next
 788                  instruction can happen for jumps with side effects.  We need
 789                  to construct a forwarder block and this will be done just
 790                  fine by force_nonfallthru below.  */
 791               if (!e_taken)
 792                 ;
 793
 794               /* There is another special case: if *neither* block is next,
 795                  such as happens at the very end of a function, then we'll
 796                  need to add a new unconditional jump.  Choose the taken
 797                  edge based on known or assumed probability.  */
 798               else if (bb->aux != e_taken->dest)
 799                 {
 800                   rtx note = find_reg_note (bb_end_insn, REG_BR_PROB, 0);
 801
 802                   if (note
 803                       && INTVAL (XEXP (note, 0)) < REG_BR_PROB_BASE / 2
 804                       && invert_jump (bb_end_insn,
 805                                       (e_fall->dest == EXIT_BLOCK_PTR
 806                                        ? NULL_RTX
 807                                        : label_for_bb (e_fall->dest)), 0))
 808                     {
 809                       e_fall->flags &= ~EDGE_FALLTHRU;
 810 #ifdef ENABLE_CHECKING
 811                       gcc_assert (could_fall_through
 812                                   (e_taken->src, e_taken->dest));
 813 #endif
 814                       e_taken->flags |= EDGE_FALLTHRU;
 815                       update_br_prob_note (bb);
 816                       e = e_fall, e_fall = e_taken, e_taken = e;
 817                     }
 818                 }
 819
 820               /* If the "jumping" edge is a crossing edge, and the fall
 821                  through edge is non-crossing, leave things as they are.  */
 822               else if ((e_taken->flags & EDGE_CROSSING)
 823                        && !(e_fall->flags & EDGE_CROSSING))
 824                 continue;
 825
 826               /* Otherwise we can try to invert the jump.  This will
 827                  basically never fail, however, keep up the pretense.  */
 828               else if (invert_jump (bb_end_insn,
 829                                     (e_fall->dest == EXIT_BLOCK_PTR
 830                                      ? NULL_RTX
 831                                      : label_for_bb (e_fall->dest)), 0))
 832                 {
 833                   e_fall->flags &= ~EDGE_FALLTHRU;
 834 #ifdef ENABLE_CHECKING
 835                   gcc_assert (could_fall_through
 836                               (e_taken->src, e_taken->dest));
 837 #endif
 838                   e_taken->flags |= EDGE_FALLTHRU;
 839                   update_br_prob_note (bb);
 840                   continue;
 841                 }
 842             }
 843           else
 844             {
 845               /* Otherwise we have some return, switch or computed
 846                  jump.  In the 99% case, there should not have been a
 847                  fallthru edge.  */
 848               gcc_assert (returnjump_p (bb_end_insn) || !e_fall);
 849               continue;
 850             }
 851         }
 852       else
 853         {
 854           /* No fallthru implies a noreturn function with EH edges, or
 855              something similarly bizarre.  In any case, we don't need to
 856              do anything.  */
 857           if (! e_fall)
 858             continue;
 859
 860           /* If the fallthru block is still next, nothing to do.  */
 861           if (bb->aux == e_fall->dest)
 862             continue;
 863
 864           /* A fallthru to exit block.  */
 865           if (e_fall->dest == EXIT_BLOCK_PTR)
 866             continue;
 867         }
 868
 869       /* We got here if we need to add a new jump insn.  */
 870       nb = force_nonfallthru (e_fall);
 871       if (nb)
 872         {
 873           nb->il.rtl->visited = 1;
 874           nb->aux = bb->aux;
 875           bb->aux = nb;
 876           /* Don't process this new block.  */
 877           bb = nb;
 878
 879           /* Make sure new bb is tagged for correct section (same as
 880              fall-thru source, since you cannot fall-throu across
 881              section boundaries).  */
 882           BB_COPY_PARTITION (e_fall->src, single_pred (bb));
 883           if (flag_reorder_blocks_and_partition
 884               && targetm.have_named_sections
 885               && JUMP_P (BB_END (bb))
 886               && !any_condjump_p (BB_END (bb))
 887               && (EDGE_SUCC (bb, 0)->flags & EDGE_CROSSING))
 888             add_reg_note (BB_END (bb), REG_CROSSING_JUMP, NULL_RTX);
 889         }
 890     }
 891
 892   relink_block_chain (/*stay_in_cfglayout_mode=*/false);
 893
 894   /* Annoying special case - jump around dead jumptables left in the code.  */
 895   FOR_EACH_BB (bb)
 896     {
 897       edge e;
 898       edge_iterator ei;
 899
 900       FOR_EACH_EDGE (e, ei, bb->succs)
 901         if (e->flags & EDGE_FALLTHRU)
 902           break;
 903
 904       if (e && !can_fallthru (e->src, e->dest))
 905         force_nonfallthru (e);
 906     }
 907
 908   /* Ensure goto_locus from edges has some instructions with that locus
 909      in RTL.  */
 910   if (!optimize)
 911     FOR_EACH_BB (bb)
 912       {
 913         edge e;
 914         edge_iterator ei;
 915
 916         FOR_EACH_EDGE (e, ei, bb->succs)
 917           if (e->goto_locus && !(e->flags & EDGE_ABNORMAL))
 918             {
 919               basic_block nb;
 920               rtx end;
 921
 922               insn = BB_END (e->src);
 923               end = PREV_INSN (BB_HEAD (e->src));
 924               while (insn != end
 925                      && (!INSN_P (insn) || INSN_LOCATOR (insn) == 0))
 926                 insn = PREV_INSN (insn);
 927               if (insn != end
 928                   && locator_eq (INSN_LOCATOR (insn), (int) e->goto_locus))
 929                 continue;
 930               if (simplejump_p (BB_END (e->src))
 931                   && INSN_LOCATOR (BB_END (e->src)) == 0)
 932                 {
 933                   INSN_LOCATOR (BB_END (e->src)) = e->goto_locus;
 934                   continue;
 935                 }
 936               if (e->dest != EXIT_BLOCK_PTR)
 937                 {
 938                   insn = BB_HEAD (e->dest);
 939                   end = NEXT_INSN (BB_END (e->dest));
 940                   while (insn != end && !INSN_P (insn))
 941                     insn = NEXT_INSN (insn);
 942                   if (insn != end && INSN_LOCATOR (insn)
 943                       && locator_eq (INSN_LOCATOR (insn), (int) e->goto_locus))
 944                     continue;
 945                 }
 946               nb = split_edge (e);
 947               if (!INSN_P (BB_END (nb)))
 948                 BB_END (nb) = emit_insn_after_noloc (gen_nop (), BB_END (nb),
 949                                                      nb);
 950               INSN_LOCATOR (BB_END (nb)) = e->goto_locus;
 951             }
 952       }
 953 }
 954 \f
 955 /* Perform sanity checks on the insn chain.
 956    1. Check that next/prev pointers are consistent in both the forward and
 957       reverse direction.
 958    2. Count insns in chain, going both directions, and check if equal.
 959    3. Check that get_last_insn () returns the actual end of chain.  */
 960
 961 void
 962 verify_insn_chain (void)
 963 {
 964   rtx x, prevx, nextx;
 965   int insn_cnt1, insn_cnt2;
 966
 967   for (prevx = NULL, insn_cnt1 = 1, x = get_insns ();
 968        x != 0;
 969        prevx = x, insn_cnt1++, x = NEXT_INSN (x))
 970     gcc_assert (PREV_INSN (x) == prevx);
 971
 972   gcc_assert (prevx == get_last_insn ());
 973
 974   for (nextx = NULL, insn_cnt2 = 1, x = get_last_insn ();
 975        x != 0;
 976        nextx = x, insn_cnt2++, x = PREV_INSN (x))
 977     gcc_assert (NEXT_INSN (x) == nextx);
 978
 979   gcc_assert (insn_cnt1 == insn_cnt2);
 980 }
 981 \f
 982 /* If we have assembler epilogues, the block falling through to exit must
 983    be the last one in the reordered chain when we reach final.  Ensure
 984    that this condition is met.  */
 985 static void
 986 fixup_fallthru_exit_predecessor (void)
 987 {
 988   edge e;
 989   edge_iterator ei;
 990   basic_block bb = NULL;
 991
 992   /* This transformation is not valid before reload, because we might
 993      separate a call from the instruction that copies the return
 994      value.  */
 995   gcc_assert (reload_completed);
 996
 997   FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
 998     if (e->flags & EDGE_FALLTHRU)
 999       bb = e->src;
1000
1001   if (bb && bb->aux)
1002     {
1003       basic_block c = ENTRY_BLOCK_PTR->next_bb;
1004
1005       /* If the very first block is the one with the fall-through exit
1006          edge, we have to split that block.  */
1007       if (c == bb)
1008         {
1009           bb = split_block (bb, NULL)->dest;
1010           bb->aux = c->aux;
1011           c->aux = bb;
1012           bb->il.rtl->footer = c->il.rtl->footer;
1013           c->il.rtl->footer = NULL;
1014         }
1015
1016       while (c->aux != bb)
1017         c = (basic_block) c->aux;
1018
1019       c->aux = bb->aux;
1020       while (c->aux)
1021         c = (basic_block) c->aux;
1022
1023       c->aux = bb;
1024       bb->aux = NULL;
1025     }
1026 }
1027
1028 /* In case there are more than one fallthru predecessors of exit, force that
1029    there is only one.  */
1030
1031 static void
1032 force_one_exit_fallthru (void)
1033 {
1034   edge e, predecessor = NULL;
1035   bool more = false;
1036   edge_iterator ei;
1037   basic_block forwarder, bb;
1038
1039   FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
1040     if (e->flags & EDGE_FALLTHRU)
1041       {
1042         if (predecessor == NULL)
1043           predecessor = e;
1044         else
1045           {
1046             more = true;
1047             break;
1048           }
1049       }
1050
1051   if (!more)
1052     return;
1053
1054   /* Exit has several fallthru predecessors.  Create a forwarder block for
1055      them.  */
1056   forwarder = split_edge (predecessor);
1057   for (ei = ei_start (EXIT_BLOCK_PTR->preds); (e = ei_safe_edge (ei)); )
1058     {
1059       if (e->src == forwarder
1060           || !(e->flags & EDGE_FALLTHRU))
1061         ei_next (&ei);
1062       else
1063         redirect_edge_and_branch_force (e, forwarder);
1064     }
1065
1066   /* Fix up the chain of blocks -- make FORWARDER immediately precede the
1067      exit block.  */
1068   FOR_EACH_BB (bb)
1069     {
1070       if (bb->aux == NULL && bb != forwarder)
1071         {
1072           bb->aux = forwarder;
1073           break;
1074         }
1075     }
1076 }
1077 \f
1078 /* Return true in case it is possible to duplicate the basic block BB.  */
1079
1080 /* We do not want to declare the function in a header file, since it should
1081    only be used through the cfghooks interface, and we do not want to move
1082    it to cfgrtl.c since it would require also moving quite a lot of related
1083    code.  */
1084 extern bool cfg_layout_can_duplicate_bb_p (const_basic_block);
1085
1086 bool
1087 cfg_layout_can_duplicate_bb_p (const_basic_block bb)
1088 {
1089   /* Do not attempt to duplicate tablejumps, as we need to unshare
1090      the dispatch table.  This is difficult to do, as the instructions
1091      computing jump destination may be hoisted outside the basic block.  */
1092   if (tablejump_p (BB_END (bb), NULL, NULL))
1093     return false;
1094
1095   /* Do not duplicate blocks containing insns that can't be copied.  */
1096   if (targetm.cannot_copy_insn_p)
1097     {
1098       rtx insn = BB_HEAD (bb);
1099       while (1)
1100         {
1101           if (INSN_P (insn) && targetm.cannot_copy_insn_p (insn))
1102             return false;
1103           if (insn == BB_END (bb))
1104             break;
1105           insn = NEXT_INSN (insn);
1106         }
1107     }
1108
1109   return true;
1110 }
1111
1112 rtx
1113 duplicate_insn_chain (rtx from, rtx to)
1114 {
1115   rtx insn, last, copy;
1116
1117   /* Avoid updating of boundaries of previous basic block.  The
1118      note will get removed from insn stream in fixup.  */
1119   last = emit_note (NOTE_INSN_DELETED);
1120
1121   /* Create copy at the end of INSN chain.  The chain will
1122      be reordered later.  */
1123   for (insn = from; insn != NEXT_INSN (to); insn = NEXT_INSN (insn))
1124     {
1125       switch (GET_CODE (insn))
1126         {
1127         case INSN:
1128         case CALL_INSN:
1129         case JUMP_INSN:
1130           /* Avoid copying of dispatch tables.  We never duplicate
1131              tablejumps, so this can hit only in case the table got
1132              moved far from original jump.  */
1133           if (GET_CODE (PATTERN (insn)) == ADDR_VEC
1134               || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC)
1135             break;
1136           copy = emit_copy_of_insn_after (insn, get_last_insn ());
1137           maybe_copy_epilogue_insn (insn, copy);
1138           break;
1139
1140         case CODE_LABEL:
1141           break;
1142
1143         case BARRIER:
1144           emit_barrier ();
1145           break;
1146
1147         case NOTE:
1148           switch (NOTE_KIND (insn))
1149             {
1150               /* In case prologue is empty and function contain label
1151                  in first BB, we may want to copy the block.  */
1152             case NOTE_INSN_PROLOGUE_END:
1153
1154             case NOTE_INSN_DELETED:
1155             case NOTE_INSN_DELETED_LABEL:
1156               /* No problem to strip these.  */
1157             case NOTE_INSN_FUNCTION_BEG:
1158               /* There is always just single entry to function.  */
1159             case NOTE_INSN_BASIC_BLOCK:
1160               break;
1161
1162             case NOTE_INSN_EPILOGUE_BEG:
1163             case NOTE_INSN_SWITCH_TEXT_SECTIONS:
1164               emit_note_copy (insn);
1165               break;
1166
1167             default:
1168               /* All other notes should have already been eliminated.  */
1169               gcc_unreachable ();
1170             }
1171           break;
1172         default:
1173           gcc_unreachable ();
1174         }
1175     }
1176   insn = NEXT_INSN (last);
1177   delete_insn (last);
1178   return insn;
1179 }
1180 /* Create a duplicate of the basic block BB.  */
1181
1182 /* We do not want to declare the function in a header file, since it should
1183    only be used through the cfghooks interface, and we do not want to move
1184    it to cfgrtl.c since it would require also moving quite a lot of related
1185    code.  */
1186 extern basic_block cfg_layout_duplicate_bb (basic_block);
1187
1188 basic_block
1189 cfg_layout_duplicate_bb (basic_block bb)
1190 {
1191   rtx insn;
1192   basic_block new_bb;
1193
1194   insn = duplicate_insn_chain (BB_HEAD (bb), BB_END (bb));
1195   new_bb = create_basic_block (insn,
1196                                insn ? get_last_insn () : NULL,
1197                                EXIT_BLOCK_PTR->prev_bb);
1198
1199   BB_COPY_PARTITION (new_bb, bb);
1200   if (bb->il.rtl->header)
1201     {
1202       insn = bb->il.rtl->header;
1203       while (NEXT_INSN (insn))
1204         insn = NEXT_INSN (insn);
1205       insn = duplicate_insn_chain (bb->il.rtl->header, insn);
1206       if (insn)
1207         new_bb->il.rtl->header = unlink_insn_chain (insn, get_last_insn ());
1208     }
1209
1210   if (bb->il.rtl->footer)
1211     {
1212       insn = bb->il.rtl->footer;
1213       while (NEXT_INSN (insn))
1214         insn = NEXT_INSN (insn);
1215       insn = duplicate_insn_chain (bb->il.rtl->footer, insn);
1216       if (insn)
1217         new_bb->il.rtl->footer = unlink_insn_chain (insn, get_last_insn ());
1218     }
1219
1220   return new_bb;
1221 }
1222
1223 \f
1224 /* Main entry point to this module - initialize the datastructures for
1225    CFG layout changes.  It keeps LOOPS up-to-date if not null.
1226
1227    FLAGS is a set of additional flags to pass to cleanup_cfg().  */
1228
1229 void
1230 cfg_layout_initialize (unsigned int flags)
1231 {
1232   rtx x;
1233   basic_block bb;
1234
1235   initialize_original_copy_tables ();
1236
1237   cfg_layout_rtl_register_cfg_hooks ();
1238
1239   record_effective_endpoints ();
1240
1241   /* Make sure that the targets of non local gotos are marked.  */
1242   for (x = nonlocal_goto_handler_labels; x; x = XEXP (x, 1))
1243     {
1244       bb = BLOCK_FOR_INSN (XEXP (x, 0));
1245       bb->flags |= BB_NON_LOCAL_GOTO_TARGET;
1246     }
1247
1248   cleanup_cfg (CLEANUP_CFGLAYOUT | flags);
1249 }
1250
1251 /* Splits superblocks.  */
1252 void
1253 break_superblocks (void)
1254 {
1255   sbitmap superblocks;
1256   bool need = false;
1257   basic_block bb;
1258
1259   superblocks = sbitmap_alloc (last_basic_block);
1260   sbitmap_zero (superblocks);
1261
1262   FOR_EACH_BB (bb)
1263     if (bb->flags & BB_SUPERBLOCK)
1264       {
1265         bb->flags &= ~BB_SUPERBLOCK;
1266         SET_BIT (superblocks, bb->index);
1267         need = true;
1268       }
1269
1270   if (need)
1271     {
1272       rebuild_jump_labels (get_insns ());
1273       find_many_sub_basic_blocks (superblocks);
1274     }
1275
1276   free (superblocks);
1277 }
1278
1279 /* Finalize the changes: reorder insn list according to the sequence specified
1280    by aux pointers, enter compensation code, rebuild scope forest.  */
1281
1282 void
1283 cfg_layout_finalize (void)
1284 {
1285 #ifdef ENABLE_CHECKING
1286   verify_flow_info ();
1287 #endif
1288   force_one_exit_fallthru ();
1289   rtl_register_cfg_hooks ();
1290   if (reload_completed
1291 #ifdef HAVE_epilogue
1292       && !HAVE_epilogue
1293 #endif
1294       )
1295     fixup_fallthru_exit_predecessor ();
1296   fixup_reorder_chain ();
1297
1298   rebuild_jump_labels (get_insns ());
1299   delete_dead_jumptables ();
1300
1301 #ifdef ENABLE_CHECKING
1302   verify_insn_chain ();
1303   verify_flow_info ();
1304 #endif
1305 }
1306
1307 /* Checks whether all N blocks in BBS array can be copied.  */
1308 bool
1309 can_copy_bbs_p (basic_block *bbs, unsigned n)
1310 {
1311   unsigned i;
1312   edge e;
1313   int ret = true;
1314
1315   for (i = 0; i < n; i++)
1316     bbs[i]->flags |= BB_DUPLICATED;
1317
1318   for (i = 0; i < n; i++)
1319     {
1320       /* In case we should redirect abnormal edge during duplication, fail.  */
1321       edge_iterator ei;
1322       FOR_EACH_EDGE (e, ei, bbs[i]->succs)
1323         if ((e->flags & EDGE_ABNORMAL)
1324             && (e->dest->flags & BB_DUPLICATED))
1325           {
1326             ret = false;
1327             goto end;
1328           }
1329
1330       if (!can_duplicate_block_p (bbs[i]))
1331         {
1332           ret = false;
1333           break;
1334         }
1335     }
1336
1337 end:
1338   for (i = 0; i < n; i++)
1339     bbs[i]->flags &= ~BB_DUPLICATED;
1340
1341   return ret;
1342 }
1343
1344 /* Duplicates N basic blocks stored in array BBS.  Newly created basic blocks
1345    are placed into array NEW_BBS in the same order.  Edges from basic blocks
1346    in BBS are also duplicated and copies of those of them
1347    that lead into BBS are redirected to appropriate newly created block.  The
1348    function assigns bbs into loops (copy of basic block bb is assigned to
1349    bb->loop_father->copy loop, so this must be set up correctly in advance)
1350    and updates dominators locally (LOOPS structure that contains the information
1351    about dominators is passed to enable this).
1352
1353    BASE is the superloop to that basic block belongs; if its header or latch
1354    is copied, we do not set the new blocks as header or latch.
1355
1356    Created copies of N_EDGES edges in array EDGES are stored in array NEW_EDGES,
1357    also in the same order.
1358
1359    Newly created basic blocks are put after the basic block AFTER in the
1360    instruction stream, and the order of the blocks in BBS array is preserved.  */
1361
1362 void
1363 copy_bbs (basic_block *bbs, unsigned n, basic_block *new_bbs,
1364           edge *edges, unsigned num_edges, edge *new_edges,
1365           struct loop *base, basic_block after)
1366 {
1367   unsigned i, j;
1368   basic_block bb, new_bb, dom_bb;
1369   edge e;
1370
1371   /* Duplicate bbs, update dominators, assign bbs to loops.  */
1372   for (i = 0; i < n; i++)
1373     {
1374       /* Duplicate.  */
1375       bb = bbs[i];
1376       new_bb = new_bbs[i] = duplicate_block (bb, NULL, after);
1377       after = new_bb;
1378       bb->flags |= BB_DUPLICATED;
1379       /* Possibly set loop header.  */
1380       if (bb->loop_father->header == bb && bb->loop_father != base)
1381         new_bb->loop_father->header = new_bb;
1382       /* Or latch.  */
1383       if (bb->loop_father->latch == bb && bb->loop_father != base)
1384         new_bb->loop_father->latch = new_bb;
1385     }
1386
1387   /* Set dominators.  */
1388   for (i = 0; i < n; i++)
1389     {
1390       bb = bbs[i];
1391       new_bb = new_bbs[i];
1392
1393       dom_bb = get_immediate_dominator (CDI_DOMINATORS, bb);
1394       if (dom_bb->flags & BB_DUPLICATED)
1395         {
1396           dom_bb = get_bb_copy (dom_bb);
1397           set_immediate_dominator (CDI_DOMINATORS, new_bb, dom_bb);
1398         }
1399     }
1400
1401   /* Redirect edges.  */
1402   for (j = 0; j < num_edges; j++)
1403     new_edges[j] = NULL;
1404   for (i = 0; i < n; i++)
1405     {
1406       edge_iterator ei;
1407       new_bb = new_bbs[i];
1408       bb = bbs[i];
1409
1410       FOR_EACH_EDGE (e, ei, new_bb->succs)
1411         {
1412           for (j = 0; j < num_edges; j++)
1413             if (edges[j] && edges[j]->src == bb && edges[j]->dest == e->dest)
1414               new_edges[j] = e;
1415
1416           if (!(e->dest->flags & BB_DUPLICATED))
1417             continue;
1418           redirect_edge_and_branch_force (e, get_bb_copy (e->dest));
1419         }
1420     }
1421
1422   /* Clear information about duplicates.  */
1423   for (i = 0; i < n; i++)
1424     bbs[i]->flags &= ~BB_DUPLICATED;
1425 }
1426
1427 #include "gt-cfglayout.h"