fortran/

[pf3gnuchains/gcc-fork.git] / gcc / cfglayout.c

diff --git a/gcc/cfglayout.c b/gcc/cfglayout.c
index c63c6f7..bcdeb96 100644 (file)
--- a/gcc/cfglayout.c
+++ b/gcc/cfglayout.c
@@ -246,7 +246,7 @@ int epilogue_locator;
    represented via INSN_NOTEs.  Replace them by representation using
    INSN_LOCATORs.  */
 
-void
+unsigned int
 insn_locators_initialize (void)
 {
   tree block = NULL;
@@ -329,6 +329,7 @@ insn_locators_initialize (void)
   set_block_levels (DECL_INITIAL (cfun->decl), 0);
 
   free_block_changes ();
+  return 0;
 }
 
 struct tree_opt_pass pass_insn_locators_initialize =
@@ -601,7 +602,7 @@ fixup_reorder_chain (void)
   /* First do the bulk reordering -- rechain the blocks without regard to
      the needed changes to jumps and labels.  */
 
-  for (bb = ENTRY_BLOCK_PTR->next_bb, index = 0;
+  for (bb = ENTRY_BLOCK_PTR->next_bb, index = NUM_FIXED_BLOCKS;
        bb != 0;
        bb = bb->aux, index++)
     {
@@ -680,41 +681,13 @@ fixup_reorder_chain (void)
                continue;
 
              /* The degenerated case of conditional jump jumping to the next
-                instruction can happen on target having jumps with side
-                effects.
-
-                Create temporarily the duplicated edge representing branch.
-                It will get unidentified by force_nonfallthru_and_redirect
-                that would otherwise get confused by fallthru edge not pointing
-                to the next basic block.  */
+                instruction can happen for jumps with side effects.  We need
+                to construct a forwarder block and this will be done just
+                fine by force_nonfallthru below.  */
              if (!e_taken)
-               {
-                 rtx note;
-                 edge e_fake;
-                 bool redirected;
-
-                 e_fake = unchecked_make_edge (bb, e_fall->dest, 0);
-
-                 redirected = redirect_jump (BB_END (bb),
-                                             block_label (bb), 0);
-                 gcc_assert (redirected);
-                 
-                 note = find_reg_note (BB_END (bb), REG_BR_PROB, NULL_RTX);
-                 if (note)
-                   {
-                     int prob = INTVAL (XEXP (note, 0));
-
-                     e_fake->probability = prob;
-                     e_fake->count = e_fall->count * prob / REG_BR_PROB_BASE;
-                     e_fall->probability -= e_fall->probability;
-                     e_fall->count -= e_fake->count;
-                     if (e_fall->probability < 0)
-                       e_fall->probability = 0;
-                     if (e_fall->count < 0)
-                       e_fall->count = 0;
-                   }
-               }
-             /* There is one special case: if *neither* block is next,
+               ;
+
+             /* There is another special case: if *neither* block is next,
                 such as happens at the very end of a function, then we'll
                 need to add a new unconditional jump.  Choose the taken
                 edge based on known or assumed probability.  */
@@ -818,7 +791,7 @@ fixup_reorder_chain (void)
   if (dump_file)
     {
       fprintf (dump_file, "Reordered sequence:\n");
-      for (bb = ENTRY_BLOCK_PTR->next_bb, index = 0;
+      for (bb = ENTRY_BLOCK_PTR->next_bb, index = NUM_FIXED_BLOCKS;
           bb;
           bb = bb->aux, index++)
        {
@@ -837,12 +810,12 @@ fixup_reorder_chain (void)
 
   prev_bb = ENTRY_BLOCK_PTR;
   bb = ENTRY_BLOCK_PTR->next_bb;
-  index = 0;
+  index = NUM_FIXED_BLOCKS;
 
   for (; bb; prev_bb = bb, bb = bb->aux, index ++)
     {
       bb->index = index;
-      BASIC_BLOCK (index) = bb;
+      SET_BASIC_BLOCK (index, bb);
 
       bb->prev_bb = prev_bb;
       prev_bb->next_bb = bb;
@@ -1243,12 +1216,15 @@ end:
    is copied, we do not set the new blocks as header or latch.
 
    Created copies of N_EDGES edges in array EDGES are stored in array NEW_EDGES,
-   also in the same order.  */
+   also in the same order.
+   
+   Newly created basic blocks are put after the basic block AFTER in the
+   instruction stream, and the order of the blocks in BBS array is preserved.  */
 
 void
 copy_bbs (basic_block *bbs, unsigned n, basic_block *new_bbs,
          edge *edges, unsigned num_edges, edge *new_edges,
-         struct loop *base)
+         struct loop *base, basic_block after)
 {
   unsigned i, j;
   basic_block bb, new_bb, dom_bb;
@@ -1259,7 +1235,8 @@ copy_bbs (basic_block *bbs, unsigned n, basic_block *new_bbs,
     {
       /* Duplicate.  */
       bb = bbs[i];
-      new_bb = new_bbs[i] = duplicate_block (bb, NULL);
+      new_bb = new_bbs[i] = duplicate_block (bb, NULL, after);
+      after = new_bb;
       bb->flags |= BB_DUPLICATED;
       /* Add to loop.  */
       add_bb_to_loop (new_bb, bb->loop_father->copy);