basic-block.h (struct edge_def): New field "count".

	* basic-block.h (struct edge_def): New field "count".
	(struct basic_block_def): Likewise.
	* flow.c (entry_exit_blocks): Add count fileds.
	(split_edge): Keep count information up-to-date.
        (dump_edge_info, dump_flow_info): Dump count fields.

	* final.c (count_instrumented_edges): Rename to edge from arc.
	(end_final): Update users.
	* profile.c: Include expr.h, basic-block.h.
	(struct adj_list, ARC_TARGET, ARC_SOURCE, ARC_COUNT): Kill.
        (struct bb_info, label_to_bb, label_to_bb_size, bb_graph): Kill.
        (ignore_next_note, return_label_execution_count): Kill.
	(bbg_file_name, da_file_name): Kill.
        (edge_info, bb_info): New structures.
        (EDGE_INFO, BB_INFO, GCOV_INDEX_TO_BB, BB_TO_GCOV_INDEX): New macros.
	(count_instrumented_edges, total_num_edges): Rename to edge from arc.
	(total_num_edges_instrumented): Likewise.
	(init_arc, expand_spanning_tree): Kill.
	(fill_spanning_tree, tablejump_entry_p): Kill.
	(instrument_edges):  Rewrite from instrument_arcs to use
	commit_edge_insertions infrastructure.
	(compute_branch_probabilities): Remove arguments; rewrite for
	CFG infrastructure; use rtl_dump_file directly.
	(branch_prob, find_spanning_tree): Likewise.
	(union_groups, find_group): New.
	(init_branch_prob): Make bbg_file_name and da_file_name local.
	(end_branch_prob): Use rtl_dump_file directly.
	(init_edge_profiler): Rename to edge from arc.
	(output_arc_profiler): Kill.
	(gen_edge_profiler): New.
	(output_func_start_profiler): Turn off profiling.  Make the
	constructor static when we can.
	* rtl.h (branch_prob, end_branch_prob): Update prototypes.

	* toplev.c (DFI_flow): Remove.
	(DFI_cfg, DFI_life): New.
	(dump_file): Update accordingly.
	(compile_file): Call end_branch_prob if profile_arc_flag too.
	(rest_of_compilation): Move flow1 cfg creation to DFI_cfg.  Do edge
	profiling after the CFG is built.  Move flow1 life analysis to
	DFI_life.  Always estimate remaining probabilities.

Co-Authored-By: Richard Henderson <rth@cygnus.com>

From-SVN: r34037

7 files changed, 699 insertions, 1210 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 5e4fc88..b8166ac 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,48 @@
+2000-05-19  Jan Hubicka  <jh@suse.cz>
+	    Richard Henderson  <rth@cygnus.com>
+
+	* basic-block.h (struct edge_def): New field "count".
+	(struct basic_block_def): Likewise.
+	* flow.c (entry_exit_blocks): Add count fileds.
+	(split_edge): Keep count information up-to-date.
+	(dump_edge_info, dump_flow_info): Dump count fields.
+
+	* final.c (count_instrumented_edges): Rename to edge from arc.
+	(end_final): Update users.
+	* profile.c: Include expr.h, basic-block.h.
+	(struct adj_list, ARC_TARGET, ARC_SOURCE, ARC_COUNT): Kill.
+	(struct bb_info, label_to_bb, label_to_bb_size, bb_graph): Kill.
+	(ignore_next_note, return_label_execution_count): Kill.
+	(bbg_file_name, da_file_name): Kill.
+	(edge_info, bb_info): New structures.
+	(EDGE_INFO, BB_INFO, GCOV_INDEX_TO_BB, BB_TO_GCOV_INDEX): New macros.
+	(count_instrumented_edges, total_num_edges): Rename to edge from arc.
+	(total_num_edges_instrumented): Likewise.
+	(init_arc, expand_spanning_tree): Kill.
+	(fill_spanning_tree, tablejump_entry_p): Kill.
+	(instrument_edges):  Rewrite from instrument_arcs to use
+	commit_edge_insertions infrastructure.
+	(compute_branch_probabilities): Remove arguments; rewrite for
+	CFG infrastructure; use rtl_dump_file directly.
+	(branch_prob, find_spanning_tree): Likewise.
+	(union_groups, find_group): New.
+	(init_branch_prob): Make bbg_file_name and da_file_name local.
+	(end_branch_prob): Use rtl_dump_file directly.
+	(init_edge_profiler): Rename to edge from arc.
+	(output_arc_profiler): Kill.
+	(gen_edge_profiler): New.
+	(output_func_start_profiler): Turn off profiling.  Make the
+	constructor static when we can.
+	* rtl.h (branch_prob, end_branch_prob): Update prototypes.
+
+	* toplev.c (DFI_flow): Remove.
+	(DFI_cfg, DFI_life): New.
+	(dump_file): Update accordingly.
+	(compile_file): Call end_branch_prob if profile_arc_flag too.
+	(rest_of_compilation): Move flow1 cfg creation to DFI_cfg.  Do edge
+	profiling after the CFG is built.  Move flow1 life analysis to
+	DFI_life.  Always estimate remaining probabilities.
+
 2000-05-19  Richard Henderson  <rth@cygnus.com>
 
 	* ifcvt.c (find_if_case_2): Don't allow THEN to be EXIT.
diff --git a/gcc/basic-block.h b/gcc/basic-block.h
index c7ae0f8..dec7707 100644
--- a/gcc/basic-block.h
+++ b/gcc/basic-block.h
@@ -129,6 +129,8 @@ typedef struct edge_def {
 
   int flags;			/* see EDGE_* below  */
   int probability;		/* biased by REG_BR_PROB_BASE */
+  int count;			/* Expected number of executions calculated
+				   in profile.c  */
 } *edge;
 
 #define EDGE_FALLTHRU		1
@@ -164,6 +166,8 @@ typedef struct basic_block_def {
 
   /* The active eh region before head and after end.  */
   int eh_beg, eh_end;
+
+  int count;		/* Expected number of executions calculated in profile.c  */
 } *basic_block;
 
 /* Number of basic blocks in the current function.  */
diff --git a/gcc/final.c b/gcc/final.c
index 2145f99..1aedfa3 100644
--- a/gcc/final.c
+++ b/gcc/final.c
@@ -159,7 +159,7 @@ static const char *last_filename;
 static int count_basic_blocks;
 
 /* Number of instrumented arcs when profile_arc_flag is set.  */
-extern int count_instrumented_arcs;
+extern int count_instrumented_edges;
 
 extern int length_unit_log; /* This is defined in insn-attrtab.c.  */
 
@@ -333,7 +333,7 @@ end_final (filename)
       if (profile_block_flag)
 	size = long_bytes * count_basic_blocks;
       else
-	size = long_bytes * count_instrumented_arcs;
+	size = long_bytes * count_instrumented_edges;
       rounded = size;
 
       rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
@@ -376,8 +376,7 @@ end_final (filename)
       if (profile_block_flag)
 	assemble_integer (GEN_INT (count_basic_blocks), long_bytes, 1);
       else
-	assemble_integer (GEN_INT (count_instrumented_arcs), long_bytes,
-			  1);
+	assemble_integer (GEN_INT (count_instrumented_edges), long_bytes, 1);
 
       /* zero word (link field) */
       assemble_integer (const0_rtx, pointer_bytes, 1);
diff --git a/gcc/flow.c b/gcc/flow.c
index b274130..08d61b15 100644
--- a/gcc/flow.c
+++ b/gcc/flow.c
@@ -194,7 +194,8 @@ struct basic_block_def entry_exit_blocks[2]
     NULL,			/* aux */
     ENTRY_BLOCK,		/* index */
     0,				/* loop_depth */
-    -1, -1			/* eh_beg, eh_end */
+    -1, -1,			/* eh_beg, eh_end */
+    0				/* count */
   },
   {
     NULL,			/* head */
@@ -207,7 +208,8 @@ struct basic_block_def entry_exit_blocks[2]
     NULL,			/* aux */
     EXIT_BLOCK,			/* index */
     0,				/* loop_depth */
-    -1, -1			/* eh_beg, eh_end */
+    -1, -1,			/* eh_beg, eh_end */
+    0				/* count */
   }
 };
 
@@ -1382,6 +1384,7 @@ split_edge (edge_in)
   /* Wire them up.  */
   bb->pred = edge_in;
   bb->succ = edge_out;
+  bb->count = edge_in->count;
 
   edge_in->dest = bb;
   edge_in->flags &= ~EDGE_CRITICAL;
@@ -1392,6 +1395,7 @@ split_edge (edge_in)
   edge_out->dest = old_succ;
   edge_out->flags = EDGE_FALLTHRU;
   edge_out->probability = REG_BR_PROB_BASE;
+  edge_out->count = edge_in->count;
 
   old_succ->pred = edge_out;
 
@@ -3809,7 +3813,7 @@ insn_dead_p (pbi, x, call_ok, notes)
 	  /* Walk the set of memory locations we are currently tracking
 	     and see if one is an identical match to this memory location.
 	     If so, this memory write is dead (remember, we're walking
-	     backwards from the end of the block to the start.  */
+	     backwards from the end of the block to the start).  */
 	  temp = pbi->mem_set_list;
 	  while (temp)
 	    {
@@ -5608,8 +5612,8 @@ dump_flow_info (file)
       register basic_block bb = BASIC_BLOCK (i);
       register edge e;
 
-      fprintf (file, "\nBasic block %d: first insn %d, last %d, loop_depth %d.\n",
-	       i, INSN_UID (bb->head), INSN_UID (bb->end), bb->loop_depth);
+      fprintf (file, "\nBasic block %d: first insn %d, last %d, loop_depth %d, count %d.\n",
+	       i, INSN_UID (bb->head), INSN_UID (bb->end), bb->loop_depth, bb->count);
 
       fprintf (file, "Predecessors: ");
       for (e = bb->pred; e ; e = e->pred_next)
@@ -5652,6 +5656,9 @@ dump_edge_info (file, e, do_succ)
   else
     fprintf (file, " %d", side->index);
 
+  if (e->count)
+    fprintf (file, " count:%d", e->count);
+
   if (e->flags)
     {
       static const char * const bitnames[] = {
@@ -5690,8 +5697,8 @@ dump_bb (bb, outf)
   rtx last;
   edge e;
 
-  fprintf (outf, ";; Basic block %d, loop depth %d",
-	   bb->index, bb->loop_depth);
+  fprintf (outf, ";; Basic block %d, loop depth %d, count %d",
+	   bb->index, bb->loop_depth, bb->count);
   if (bb->eh_beg != -1 || bb->eh_end != -1)
     fprintf (outf, ", eh regions %d/%d", bb->eh_beg, bb->eh_end);
   putc ('\n', outf);
diff --git a/gcc/profile.c b/gcc/profile.c
index 69ac575..960fbec 100644
--- a/gcc/profile.c
+++ b/gcc/profile.c
@@ -21,10 +21,6 @@ along with GNU CC; see the file COPYING.  If not, write to
 the Free Software Foundation, 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 
-/* ??? Really should not put insns inside of LIBCALL sequences, when putting
-   insns after a call, should look for the insn setting the retval, and
-   insert the insns after that one.  */
-
 /* ??? Register allocation should use basic block execution counts to
    give preference to the most commonly executed blocks.  */
 
@@ -36,11 +32,6 @@ Boston, MA 02111-1307, USA.  */
 /* ??? Should calculate branch probabilities before instrumenting code, since
    then we can use arc counts to help decide which arcs to instrument.  */
 
-/* ??? Rearrange code so that the most frequently executed arcs become from
-   one block to the next block (i.e. a fall through), move seldom executed
-   code outside of loops even at the expense of adding a few branches to
-   achieve this, see Dain Sample's UC Berkeley thesis.  */
-
 #include "config.h"
 #include "system.h"
 #include "rtl.h"
@@ -50,68 +41,46 @@ Boston, MA 02111-1307, USA.  */
 #include "insn-config.h"
 #include "output.h"
 #include "regs.h"
+#include "expr.h"
 #include "function.h"
 #include "gcov-io.h"
 #include "toplev.h"
 #include "ggc.h"
+#include "basic-block.h"
 
-/* One of these is dynamically created whenever we identify an arc in the
-   function.  */
-
-struct adj_list
-{
-  int source;
-  int target;
-  int arc_count;
-  unsigned int count_valid : 1;
-  unsigned int on_tree : 1;
-  unsigned int fake : 1;
-  unsigned int fall_through : 1;
-  rtx branch_insn;
-  struct adj_list *pred_next;
-  struct adj_list *succ_next;
-};
-
-#define ARC_TARGET(ARCPTR) (ARCPTR->target)
-#define ARC_SOURCE(ARCPTR) (ARCPTR->source)
-#define ARC_COUNT(ARCPTR)  (ARCPTR->arc_count)
-
-/* Count the number of basic blocks, and create an array of these structures,
-   one for each bb in the function.  */
 
+/* Additional information about the edges we need.  */
+struct edge_info
+  {
+    unsigned int count_valid : 1;
+    unsigned int on_tree : 1;
+    unsigned int ignore : 1;
+  };
 struct bb_info
-{
-  struct adj_list *succ;
-  struct adj_list *pred;
-  int succ_count;
-  int pred_count;
-  int exec_count;
-  unsigned int count_valid : 1;
-  unsigned int on_tree : 1;
-  rtx first_insn;
-};
-
-/* Indexed by label number, gives the basic block number containing that
-   label.  */
-
-static int *label_to_bb;
-
-/* Number of valid entries in the label_to_bb array.  */
-
-static int label_to_bb_size;
-
-/* Indexed by block index, holds the basic block graph.  */
-
-static struct bb_info *bb_graph;
+  {
+    unsigned int count_valid : 1;
+    int succ_count;
+    int pred_count;
+  };
+
+#define EDGE_INFO(e)  ((struct edge_info *) (e)->aux)
+#define BB_INFO(b)  ((struct bb_info *) (b)->aux)
+
+/* Keep all basic block indexes nonnegative in the gcov output.  Index 0
+   is used for entry block, last block exit block.   */
+#define GCOV_INDEX_TO_BB(i)  ((i) == 0 ? ENTRY_BLOCK_PTR		\
+    			      : (((i) == n_basic_blocks + 1)		\
+			         ? EXIT_BLOCK_PTR : BASIC_BLOCK ((i)-1)))
+#define BB_TO_GCOV_INDEX(bb)  ((bb) == ENTRY_BLOCK_PTR ? 0 		\
+  			       : ((bb) == EXIT_BLOCK_PTR		\
+				  ? n_basic_blocks + 1 : (bb)->index + 1))
 
 /* Name and file pointer of the output file for the basic block graph.  */
 
-static char *bbg_file_name;
 static FILE *bbg_file;
 
 /* Name and file pointer of the input file for the arc count data.  */
 
-static char *da_file_name;
 static FILE *da_file;
 
 /* Pointer of the output file for the basic block/line number map. */
@@ -121,27 +90,17 @@ static FILE *bb_file;
 
 static char *last_bb_file_name;
 
-/* Indicates whether the next line number note should be output to
-   bb_file or not.  Used to eliminate a redundant note after an
-   expanded inline function call.  */
-
-static int ignore_next_note;
-
 /* Used by final, for allocating the proper amount of storage for the
    instrumented arc execution counts.  */
 
-int count_instrumented_arcs;
-
-/* Number of executions for the return label.  */
-
-int return_label_execution_count;
+int count_instrumented_edges;
 
 /* Collect statistics on the performance of this pass for the entire source
    file.  */
 
 static int total_num_blocks;
-static int total_num_arcs;
-static int total_num_arcs_instrumented;
+static int total_num_edges;
+static int total_num_edges_instrumented;
 static int total_num_blocks_created;
 static int total_num_passes;
 static int total_num_times_called;
@@ -150,16 +109,14 @@ static int total_num_never_executed;
 static int total_num_branches;
 
 /* Forward declarations.  */
-static void init_arc PARAMS ((struct adj_list *, int, int, rtx));
-static void find_spanning_tree PARAMS ((int));
-static void expand_spanning_tree PARAMS ((int));
-static void fill_spanning_tree PARAMS ((int));
-static void init_arc_profiler PARAMS ((void));
-static void output_arc_profiler PARAMS ((int, rtx));
-static void instrument_arcs PARAMS ((rtx, int, FILE *));
+static void find_spanning_tree PARAMS ((struct edge_list *));
+static void init_edge_profiler PARAMS ((void));
+static rtx gen_edge_profiler PARAMS ((int));
+static void instrument_edges PARAMS ((struct edge_list *));
 static void output_gcov_string PARAMS ((const char *, long));
-static int tablejump_entry_p PARAMS ((rtx, rtx));
-static void compute_branch_probabilities PARAMS ((int, FILE *));
+static void compute_branch_probabilities PARAMS ((void));
+static basic_block find_group PARAMS ((basic_block));
+static void union_groups PARAMS ((basic_block, basic_block));
 
 #ifndef LONG_TYPE_SIZE
 #define LONG_TYPE_SIZE BITS_PER_WORD
@@ -168,223 +125,53 @@ static void compute_branch_probabilities PARAMS ((int, FILE *));
 /* If non-zero, we need to output a constructor to set up the
    per-object-file data. */
 static int need_func_profiler = 0;
-
 
-/* Add arc instrumentation code to the entire insn chain.
+/* Add edge instrumentation code to the entire insn chain.
 
    F is the first insn of the chain.
-   NUM_BLOCKS is the number of basic blocks found in F.
-   DUMP_FILE, if nonzero, is an rtl dump file we can write to.  */
+   NUM_BLOCKS is the number of basic blocks found in F.  */
 
 static void
-instrument_arcs (f, num_blocks, dump_file)
-     rtx f;
-     int num_blocks;
-     FILE *dump_file;
+instrument_edges (el)
+     struct edge_list *el;
 {
-  register int i;
-  register struct adj_list *arcptr, *backptr;
-  int num_arcs = 0;
-  int num_instr_arcs = 0;
-  rtx insn;
-
-  /* Instrument the program start.  */
-  /* Handle block 0 specially, since it will always be instrumented,
-     but it doesn't have a valid first_insn or branch_insn.  We must
-     put the instructions before the NOTE_INSN_FUNCTION_BEG note, so
-     that they don't clobber any of the parameters of the current
-     function.  */
-  for (insn = f; insn; insn = NEXT_INSN (insn))
-    if (GET_CODE (insn) == NOTE
-	&& NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG)
-      break;
-  insn = PREV_INSN (insn);
-  need_func_profiler = 1;
-  output_arc_profiler (total_num_arcs_instrumented + num_instr_arcs++, insn);
-
-  for (i = 1; i < num_blocks; i++)
-    for (arcptr = bb_graph[i].succ; arcptr; arcptr = arcptr->succ_next)
-      if (! arcptr->on_tree)
+  int i;
+  int num_instr_edges = 0;
+  int num_edges = NUM_EDGES (el);
+  remove_fake_edges ();
+
+  for (i = 0; i < n_basic_blocks + 2; i++)
+    {
+      basic_block bb = GCOV_INDEX_TO_BB (i);
+      edge e = bb->succ;
+      while (e)
 	{
-	  if (dump_file)
-	    fprintf (dump_file, "Arc %d to %d instrumented\n", i,
-		     ARC_TARGET (arcptr));
-
-	  /* Check to see if this arc is the only exit from its source block,
-	     or the only entrance to its target block.  In either case,
-	     we don't need to create a new block to instrument the arc.  */
-	  
-	  if (bb_graph[i].succ == arcptr && arcptr->succ_next == 0)
-	    {
-	      /* Instrument the source block.  */
-	      output_arc_profiler (total_num_arcs_instrumented
-				   + num_instr_arcs++,
-				   PREV_INSN (bb_graph[i].first_insn));
-	    }
-	  else if (arcptr == bb_graph[ARC_TARGET (arcptr)].pred
-		   && arcptr->pred_next == 0)
+	  struct edge_info *inf = EDGE_INFO (e);
+	  if (!inf->ignore && !inf->on_tree)
 	    {
-	      /* Instrument the target block.  */
-	      output_arc_profiler (total_num_arcs_instrumented
-				   + num_instr_arcs++, 
-				   PREV_INSN (bb_graph[ARC_TARGET (arcptr)].first_insn));
-	    }
-	  else if (arcptr->fall_through)
-	    {
-	      /* This is a fall-through; put the instrumentation code after
-		 the branch that ends this block.  */
-	      
-	      for (backptr = bb_graph[i].succ; backptr;
-		   backptr = backptr->succ_next)
-		if (backptr != arcptr)
-		  break;
-	      
-	      output_arc_profiler (total_num_arcs_instrumented
-				   + num_instr_arcs++,
-				   backptr->branch_insn);
-	    }
-	  else
-	    {
-	      /* Must emit a new basic block to hold the arc counting code.  */
-	      enum rtx_code code = GET_CODE (PATTERN (arcptr->branch_insn));
-
-	      if (code == SET)
-		{
-		  /* Create the new basic block right after the branch.
-		     Invert the branch so that it jumps past the end of the new
-		     block.  The new block will consist of the instrumentation
-		     code, and a jump to the target of this arc.  */
-		  int this_is_simplejump = simplejump_p (arcptr->branch_insn);
-		  rtx new_label = gen_label_rtx ();
-		  rtx old_label, set_src;
-		  rtx after = arcptr->branch_insn;
-		  
-		  /* Simplejumps can't reach here.  */
-		  if (this_is_simplejump)
-		    abort ();
-
-		  /* We can't use JUMP_LABEL, because it won't be set if we
-		     are compiling without optimization.  */
-
-		  set_src = SET_SRC (single_set (arcptr->branch_insn));
-		  if (GET_CODE (set_src) == LABEL_REF)
-		    old_label = set_src;
-		  else if (GET_CODE (set_src) != IF_THEN_ELSE)
-		    abort ();
-		  else if (XEXP (set_src, 1) == pc_rtx)
-		    old_label = XEXP (XEXP (set_src, 2), 0);
-		  else
-		    old_label = XEXP (XEXP (set_src, 1), 0);
-
-		  /* Set the JUMP_LABEL so that redirect_jump will work.  */
-		  JUMP_LABEL (arcptr->branch_insn) = old_label;
-
-		  /* Add a use for OLD_LABEL that will be needed when we emit
-		     the JUMP_INSN below.  If we don't do this here,
-		     `invert_jump' might delete it for us.  We must add two
-		     when not optimizing, because the NUSES is zero now,
-		     but must be at least two to prevent the label from being
-		     deleted.  */
-		  LABEL_NUSES (old_label) += 2;
-		  
-		  /* Emit the insns for the new block in reverse order,
-		     since that is most convenient.  */
-
-		  if (this_is_simplejump)
-		    {
-		      after = NEXT_INSN (arcptr->branch_insn);
-		      if (! redirect_jump (arcptr->branch_insn, new_label, 1))
-			/* Don't know what to do if this branch won't
-			   redirect.  */
-			abort ();
-		    }
-		  else
-		    {
-		      if (! invert_jump (arcptr->branch_insn, new_label, 1))
-			/* Don't know what to do if this branch won't invert.  */
-			abort ();
-
-		      emit_label_after (new_label, after);
-		      LABEL_NUSES (new_label)++;
-		    }
-		  emit_barrier_after (after);
-		  emit_jump_insn_after (gen_jump (old_label), after);
-		  JUMP_LABEL (NEXT_INSN (after)) = old_label;
-		  
-		  /* Instrument the source arc.  */
-		  output_arc_profiler (total_num_arcs_instrumented
-				       + num_instr_arcs++,
-				       after);
-		  if (this_is_simplejump)
-		    {
-		      emit_label_after (new_label, after);
-		      LABEL_NUSES (new_label)++;
-		    }
-		}
-	      else if (code == ADDR_VEC || code == ADDR_DIFF_VEC)
-		{
-		  /* A table jump.  Create a new basic block immediately
-		     after the table, by emitting a barrier, a label, a
-		     counting note, and a jump to the old label.  Put the
-		     new label in the table.  */
-		  
-		  rtx new_label = gen_label_rtx ();
-		  rtx old_lref, new_lref;
-		  int index;
-		  
-		  /* Must determine the old_label reference, do this
-		     by counting the arcs after this one, which will
-		     give the index of our label in the table.  */
-		  
-		  index = 0;
-		  for (backptr = arcptr->succ_next; backptr;
-		       backptr = backptr->succ_next)
-		    index++;
-		  
-		  old_lref = XVECEXP (PATTERN (arcptr->branch_insn),
-				      (code == ADDR_DIFF_VEC), index);
-		  
-		  /* Emit the insns for the new block in reverse order,
-		     since that is most convenient.  */
-		  emit_jump_insn_after (gen_jump (XEXP (old_lref, 0)),
-					arcptr->branch_insn);
-		  JUMP_LABEL (NEXT_INSN (arcptr->branch_insn))
-		    = XEXP (old_lref, 0);
-
-		  /* Instrument the source arc.  */
-		  output_arc_profiler (total_num_arcs_instrumented
-				       + num_instr_arcs++,
-				       arcptr->branch_insn);
-
-		  emit_label_after (new_label, arcptr->branch_insn);
-		  LABEL_NUSES (NEXT_INSN (arcptr->branch_insn))++;
-		  emit_barrier_after (arcptr->branch_insn);
-		  
-		  /* Fix up the table jump.  */
-		  new_lref = gen_rtx_LABEL_REF (Pmode, new_label);
-		  XVECEXP (PATTERN (arcptr->branch_insn),
-			   (code == ADDR_DIFF_VEC), index) = new_lref;
-		}
-	      else
+	      if (e->flags & EDGE_ABNORMAL)
 		abort ();
-
-	      num_arcs += 1;
-	      if (dump_file)
-		fprintf (dump_file,
-			 "Arc %d to %d needed new basic block\n", i,
-			 ARC_TARGET (arcptr));
+	      if (rtl_dump_file)
+		fprintf (rtl_dump_file, "Edge %d to %d instrumented%s\n",
+			 e->src->index, e->dest->index,
+			 e->flags & EDGE_CRITICAL ? " (and split)" : "");
+	      need_func_profiler = 1;
+	      insert_insn_on_edge (
+			 gen_edge_profiler (total_num_edges_instrumented
+					    + num_instr_edges++), e);
 	    }
+	  e = e->succ_next;
 	}
-  
-  total_num_arcs_instrumented += num_instr_arcs;
-  count_instrumented_arcs = total_num_arcs_instrumented;
-
-  total_num_blocks_created += num_arcs;
-  if (dump_file)
-    {
-      fprintf (dump_file, "%d arcs instrumented\n", num_instr_arcs);
-      fprintf (dump_file, "%d extra basic blocks created\n", num_arcs);
     }
+
+  total_num_edges_instrumented += num_instr_edges;
+  count_instrumented_edges = total_num_edges_instrumented;
+
+  total_num_blocks_created += num_edges;
+  if (rtl_dump_file)
+    fprintf (rtl_dump_file, "%d edges instrumented\n", num_instr_edges);
+
+  commit_edge_insertions ();
 }
 
 /* Output STRING to bb_file, surrounded by DELIMITER.  */
@@ -413,93 +200,96 @@ output_gcov_string (string, delimiter)
       fwrite (c, sizeof (char), 4 - temp, bb_file);
     }
 
-  /* Store another delimiter in the .bb file, just to make it easy to find the
-     end of the file name.  */
+  /* Store another delimiter in the .bb file, just to make it easy to find
+     the end of the file name.  */
   __write_long (delimiter, bb_file, 4);
 }
 
-/* Return TRUE if this insn must be a tablejump entry insn.  This works for
-   the MIPS port, but may give false negatives for some targets.  */
-
-static int
-tablejump_entry_p (insn, label)
-     rtx insn, label;
-{
-  rtx next = next_active_insn (insn);
-  enum rtx_code code = GET_CODE (PATTERN (next));
-
-  if (code != ADDR_DIFF_VEC && code != ADDR_VEC)
-    return 0;
-
-  if (PREV_INSN (next) == XEXP (label, 0))
-    return 1;
-
-  return 0;
-}
 
 /* Compute the branch probabilities for the various branches.
    Annotate them accordingly.  */
 
 static void
-compute_branch_probabilities (num_blocks, dump_file)
-     int num_blocks;
-     FILE *dump_file;
+compute_branch_probabilities ()
 {
   int i;
-  int bad_counts = 0;
-  int num_arcs;
+  int num_edges = 0;
   int changes;
   int passes;
-  int prob;
-  int total;
-  int num_branches;
-  int num_never_executed;
   int hist_br_prob[20];
-  struct adj_list *arcptr;
+  int num_never_executed;
+  int num_branches;
+  int bad_counts = 0;
+  struct bb_info *bb_infos;
 
-  /* For each arc not on the spanning tree, set its execution count from
+  /* Attach extra info block to each bb.  */
+
+  bb_infos = (struct bb_info *)
+    xcalloc (n_basic_blocks + 2, sizeof (struct bb_info));
+  for (i = 0; i < n_basic_blocks + 2; i++)
+    {
+      basic_block bb = GCOV_INDEX_TO_BB (i);
+      edge e;
+
+      bb->aux = &bb_infos[i];
+      for (e = bb->succ; e; e = e->succ_next)
+	if (!EDGE_INFO (e)->ignore)
+	  BB_INFO (bb)->succ_count++;
+      for (e = bb->pred; e; e = e->pred_next)
+	if (!EDGE_INFO (e)->ignore)
+	  BB_INFO (bb)->pred_count++;
+    }
+
+  /* Avoid predicting entry on exit nodes.  */
+  BB_INFO (EXIT_BLOCK_PTR)->succ_count = 2;
+  BB_INFO (ENTRY_BLOCK_PTR)->pred_count = 2;
+
+  /* For each edge not on the spanning tree, set its execution count from
      the .da file.  */
 
   /* The first count in the .da file is the number of times that the function
      was entered.  This is the exec_count for block zero.  */
 
-  num_arcs = 0;
-  for (i = 0; i < num_blocks; i++)
-    for (arcptr = bb_graph[i].succ; arcptr; arcptr = arcptr->succ_next)
-      if (! arcptr->on_tree)
-	{
-	  num_arcs++;
-	  if (da_file)
-	    {
-	      long value;
-	      __read_long (&value, da_file, 8);
-	      ARC_COUNT (arcptr) = value;
-	    }
-	  else
-	    ARC_COUNT (arcptr) = 0;
-	  arcptr->count_valid = 1;
-	  bb_graph[i].succ_count--;
-	  bb_graph[ARC_TARGET (arcptr)].pred_count--;
-	}
+  for (i = 0; i < n_basic_blocks + 2; i++)
+    {
+      basic_block bb = GCOV_INDEX_TO_BB (i);
+      edge e;
+      for (e = bb->succ; e; e = e->succ_next)
+	if (!EDGE_INFO (e)->ignore && !EDGE_INFO (e)->on_tree)
+	  {
+	    num_edges++;
+	    if (da_file)
+	      {
+		long value;
+		__read_long (&value, da_file, 8);
+		e->count = value;
+	      }
+	    else
+	      e->count = 0;
+	    EDGE_INFO (e)->count_valid = 1;
+	    BB_INFO (bb)->succ_count--;
+	    BB_INFO (e->dest)->pred_count--;
+	  }
+    }
 
-  if (dump_file)
-    fprintf (dump_file, "%d arc counts read\n", num_arcs);
+  if (rtl_dump_file)
+    fprintf (rtl_dump_file, "%d edge counts read\n", num_edges);
 
   /* For every block in the file,
-     - if every exit/entrance arc has a known count, then set the block count
-     - if the block count is known, and every exit/entrance arc but one has
-       a known execution count, then set the count of the remaining arc
+     - if every exit/entrance edge has a known count, then set the block count
+     - if the block count is known, and every exit/entrance edge but one has
+     a known execution count, then set the count of the remaining edge
 
-     As arc counts are set, decrement the succ/pred count, but don't delete
-     the arc, that way we can easily tell when all arcs are known, or only
-     one arc is unknown.  */
+     As edge counts are set, decrement the succ/pred count, but don't delete
+     the edge, that way we can easily tell when all edges are known, or only
+     one edge is unknown.  */
 
   /* The order that the basic blocks are iterated through is important.
      Since the code that finds spanning trees starts with block 0, low numbered
-     arcs are put on the spanning tree in preference to high numbered arcs.
-     Hence, most instrumented arcs are at the end.  Graph solving works much
+     edges are put on the spanning tree in preference to high numbered edges.
+     Hence, most instrumented edges are at the end.  Graph solving works much
      faster if we propagate numbers from the end to the start.
-     
+
      This takes an average of slightly more than 3 passes.  */
 
   changes = 1;
@@ -508,101 +298,111 @@ compute_branch_probabilities (num_blocks, dump_file)
     {
       passes++;
       changes = 0;
-
-      for (i = num_blocks - 1; i >= 0; i--)
+      for (i = n_basic_blocks + 1; i >= 0; i--)
 	{
-	  struct bb_info *binfo = &bb_graph[i];
-	  if (! binfo->count_valid)
+	  basic_block bb = GCOV_INDEX_TO_BB (i);
+	  struct bb_info *bi = BB_INFO (bb);
+	  if (! bi->count_valid)
 	    {
-	      if (binfo->succ_count == 0)
+	      if (bi->succ_count == 0)
 		{
-		  total = 0;
-		  for (arcptr = binfo->succ; arcptr;
-		       arcptr = arcptr->succ_next)
-		    total += ARC_COUNT (arcptr);
-		  binfo->exec_count = total;
-		  binfo->count_valid = 1;
+		  edge e;
+		  int total = 0;
+
+		  for (e = bb->succ; e; e = e->succ_next)
+		    total += e->count;
+		  bb->count = total;
+		  bi->count_valid = 1;
 		  changes = 1;
 		}
-	      else if (binfo->pred_count == 0)
+	      else if (bi->pred_count == 0)
 		{
-		  total = 0;
-		  for (arcptr = binfo->pred; arcptr;
-		       arcptr = arcptr->pred_next)
-		    total += ARC_COUNT (arcptr);
-		  binfo->exec_count = total;
-		  binfo->count_valid = 1;
+		  edge e;
+		  int total = 0;
+
+		  for (e = bb->pred; e; e = e->pred_next)
+		    total += e->count;
+		  bb->count = total;
+		  bi->count_valid = 1;
 		  changes = 1;
 		}
 	    }
-	  if (binfo->count_valid)
+	  if (bi->count_valid)
 	    {
-	      if (binfo->succ_count == 1)
+	      if (bi->succ_count == 1)
 		{
-		  total = 0;
+		  edge e;
+		  int total = 0;
+
 		  /* One of the counts will be invalid, but it is zero,
 		     so adding it in also doesn't hurt.  */
-		  for (arcptr = binfo->succ; arcptr;
-		       arcptr = arcptr->succ_next)
-		    total += ARC_COUNT (arcptr);
-		  /* Calculate count for remaining arc by conservation.  */
-		  total = binfo->exec_count - total;
-		  /* Search for the invalid arc, and set its count.  */
-		  for (arcptr = binfo->succ; arcptr;
-		       arcptr = arcptr->succ_next)
-		    if (! arcptr->count_valid)
+		  for (e = bb->succ; e; e = e->succ_next)
+		    total += e->count;
+
+		  /* Seedgeh for the invalid edge, and set its count.  */
+		  for (e = bb->succ; e; e = e->succ_next)
+		    if (! EDGE_INFO (e)->count_valid && ! EDGE_INFO (e)->ignore)
 		      break;
-		  if (! arcptr)
+
+		  /* Calculate count for remaining edge by conservation.  */
+		  total = bb->count - total;
+
+		  if (! e)
 		    abort ();
-		  arcptr->count_valid = 1;
-		  ARC_COUNT (arcptr) = total;
-		  binfo->succ_count--;
+		  EDGE_INFO (e)->count_valid = 1;
+		  e->count = total;
+		  bi->succ_count--;
 		  
-		  bb_graph[ARC_TARGET (arcptr)].pred_count--;
+		  BB_INFO (e->dest)->pred_count--;
 		  changes = 1;
 		}
-	      if (binfo->pred_count == 1)
+	      if (bi->pred_count == 1)
 		{
-		  total = 0;
+		  edge e;
+		  int total = 0;
+
 		  /* One of the counts will be invalid, but it is zero,
 		     so adding it in also doesn't hurt.  */
-		  for (arcptr = binfo->pred; arcptr;
-		       arcptr = arcptr->pred_next)
-		    total += ARC_COUNT (arcptr);
-		  /* Calculate count for remaining arc by conservation.  */
-		  total = binfo->exec_count - total;
-		  /* Search for the invalid arc, and set its count.  */
-		  for (arcptr = binfo->pred; arcptr;
-		       arcptr = arcptr->pred_next)
-		    if (! arcptr->count_valid)
+		  for (e = bb->pred; e; e = e->pred_next)
+		    total += e->count;
+
+		  /* Seedgeh for the invalid edge, and set its count.  */
+		  for (e = bb->pred; e; e = e->pred_next)
+		    if (! EDGE_INFO (e)->count_valid && ! EDGE_INFO (e)->ignore)
 		      break;
-		  if (! arcptr)
+
+		  /* Calculate count for remaining edge by conservation.  */
+		  total = bb->count - total + e->count;
+
+		  if (! e)
 		    abort ();
-		  arcptr->count_valid = 1;
-		  ARC_COUNT (arcptr) = total;
-		  binfo->pred_count--;
+		  EDGE_INFO (e)->count_valid = 1;
+		  e->count = total;
+		  bi->pred_count--;
 		  
-		  bb_graph[ARC_SOURCE (arcptr)].succ_count--;
+		  BB_INFO (e->src)->succ_count--;
 		  changes = 1;
 		}
 	    }
 	}
     }
+  if (rtl_dump_file)
+    dump_flow_info (rtl_dump_file);
 
   total_num_passes += passes;
-  if (dump_file)
-    fprintf (dump_file, "Graph solving took %d passes.\n\n", passes);
+  if (rtl_dump_file)
+    fprintf (rtl_dump_file, "Graph solving took %d passes.\n\n", passes);
 
   /* If the graph has been correctly solved, every block will have a
      succ and pred count of zero.  */
-  for (i = 0; i < num_blocks; i++)
+  for (i = 0; i < n_basic_blocks; i++)
     {
-      struct bb_info *binfo = &bb_graph[i];
-      if (binfo->succ_count || binfo->pred_count)
+      basic_block bb = BASIC_BLOCK (i);
+      if (BB_INFO (bb)->succ_count || BB_INFO (bb)->pred_count)
 	abort ();
     }
 
-  /* For every arc, calculate its branch probability and add a reg_note
+  /* For every edge, calculate its branch probability and add a reg_note
      to the branch insn to indicate this.  */
 
   for (i = 0; i < 20; i++)
@@ -610,57 +410,47 @@ compute_branch_probabilities (num_blocks, dump_file)
   num_never_executed = 0;
   num_branches = 0;
 
-  for (i = 0; i < num_blocks; i++)
+  for (i = 0; i < n_basic_blocks; i++)
     {
-      struct bb_info *binfo = &bb_graph[i];
-
-      total = binfo->exec_count;
-      for (arcptr = binfo->succ; arcptr; arcptr = arcptr->succ_next)
+      basic_block bb = BASIC_BLOCK (i);
+      edge e;
+      rtx insn;
+      int total;
+      rtx note;
+
+      total = bb->count;
+      if (!total)
+	continue;
+      for (e = bb->succ; e; e = e->succ_next)
 	{
-	  if (arcptr->branch_insn)
+	  if (any_condjump_p (e->src->end)
+	      && !EDGE_INFO (e)->ignore
+	      && !(e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_FAKE)))
 	    {
+	      int prob;
 	      /* This calculates the branch probability as an integer between
 		 0 and REG_BR_PROB_BASE, properly rounded to the nearest
 		 integer.  Perform the arithmetic in double to avoid
 		 overflowing the range of ints.  */
-
 	      if (total == 0)
 		prob = -1;
 	      else
 		{
-		  rtx pat = PATTERN (arcptr->branch_insn);
-		  
-		  prob = (((double)ARC_COUNT (arcptr) * REG_BR_PROB_BASE)
+		  prob = (((double)e->count * REG_BR_PROB_BASE)
 			  + (total >> 1)) / total;
 		  if (prob < 0 || prob > REG_BR_PROB_BASE)
 		    {
-		      if (dump_file)
-			fprintf (dump_file, "bad count: prob for %d-%d thought to be %d (forcibly normalized)\n",
-				 ARC_SOURCE (arcptr), ARC_TARGET (arcptr),
-				 prob);
+		      if (rtl_dump_file)
+			fprintf (rtl_dump_file, "bad count: prob for %d-%d thought to be %d (forcibly normalized)\n",
+				 e->src->index, e->dest->index, prob);
 
 		      bad_counts = 1;
 		      prob = REG_BR_PROB_BASE / 2;
 		    }
 		  
 		  /* Match up probability with JUMP pattern.  */
-
-		  if (GET_CODE (pat) == SET
-		      && GET_CODE (SET_SRC (pat)) == IF_THEN_ELSE)
-		    {
-		      if (ARC_TARGET (arcptr) == ARC_SOURCE (arcptr) + 1)
-			{
-			  /* A fall through arc should never have a
-			     branch insn.  */
-			  abort ();
-			}
-		      else
-			{
-			  /* This is the arc for the taken branch.  */
-			  if (GET_CODE (XEXP (SET_SRC (pat), 2)) != PC)
-			    prob = REG_BR_PROB_BASE - prob;
-			}
-		    }
+		  if (e->flags & EDGE_FALLTHRU)
+		    prob = REG_BR_PROB_BASE - prob;
 		}
 	      
 	      if (prob == -1)
@@ -674,66 +464,68 @@ compute_branch_probabilities (num_blocks, dump_file)
 		}
 	      num_branches++;
 	      
-	      REG_NOTES (arcptr->branch_insn)
-		= gen_rtx_EXPR_LIST (REG_BR_PROB, GEN_INT (prob),
-				     REG_NOTES (arcptr->branch_insn));
+	      note = find_reg_note (e->src->end, REG_BR_PROB, 0);
+	      /* There may be already note put by some other pass, such
+	         as builtin_expect expander.  */
+	      if (note)
+		XEXP (note, 0) = GEN_INT (prob);
+	      else
+		REG_NOTES (e->src->end)
+		  = gen_rtx_EXPR_LIST (REG_BR_PROB, GEN_INT (prob),
+				       REG_NOTES (e->src->end));
 	    }
 	}
 
       /* Add a REG_EXEC_COUNT note to the first instruction of this block.  */
-      if (! binfo->first_insn 
-	  || GET_RTX_CLASS (GET_CODE (binfo->first_insn)) != 'i')
-	{
-	  /* Block 0 is a fake block representing function entry, and does
-	     not have a real first insn.  The second last block might not
-	     begin with a real insn.  */
-	  if (i == num_blocks - 1)
-	    return_label_execution_count = total;
-	  else if (i != 0 && i != num_blocks - 2)
-	    abort ();
-	}
-      else
-	{
-	  REG_NOTES (binfo->first_insn)
-	    = gen_rtx_EXPR_LIST (REG_EXEC_COUNT, GEN_INT (total),
-				 REG_NOTES (binfo->first_insn));
-	  if (i == num_blocks - 1)
-	    return_label_execution_count = total;
-	}
+      insn = next_nonnote_insn (bb->head);
+
+      if (GET_CODE (bb->head) == CODE_LABEL)
+	insn = next_nonnote_insn (insn);
+
+      /* Avoid crash on empty basic blocks.  */
+      if (insn && INSN_P (insn))
+	REG_NOTES (insn)
+	  = gen_rtx_EXPR_LIST (REG_EXEC_COUNT, GEN_INT (total),
+			       REG_NOTES (insn));
     }
   
   /* This should never happen.  */
   if (bad_counts)
-    warning ("Arc profiling: some arc counts were bad.");
+    warning ("Arc profiling: some edge counts were bad.");
 
-  if (dump_file)
+  if (rtl_dump_file)
     {
-      fprintf (dump_file, "%d branches\n", num_branches);
-      fprintf (dump_file, "%d branches never executed\n",
+      fprintf (rtl_dump_file, "%d branches\n", num_branches);
+      fprintf (rtl_dump_file, "%d branches never executed\n",
 	       num_never_executed);
       if (num_branches)
 	for (i = 0; i < 10; i++)
-	  fprintf (dump_file, "%d%% branches in range %d-%d%%\n",
-		   (hist_br_prob[i]+hist_br_prob[19-i])*100/num_branches,
-		   5*i, 5*i+5);
+	  fprintf (rtl_dump_file, "%d%% branches in range %d-%d%%\n",
+		   (hist_br_prob[i] + hist_br_prob[19-i]) * 100 / num_branches,
+		   5 * i, 5 * i + 5);
 
       total_num_branches += num_branches;
       total_num_never_executed += num_never_executed;
       for (i = 0; i < 20; i++)
 	total_hist_br_prob[i] += hist_br_prob[i];
+
+      fputc ('\n', rtl_dump_file);
+      fputc ('\n', rtl_dump_file);
     }
+
+  free (bb_infos);
 }
 
 /* Instrument and/or analyze program behavior based on program flow graph.
    In either case, this function builds a flow graph for the function being
    compiled.  The flow graph is stored in BB_GRAPH.
 
-   When FLAG_PROFILE_ARCS is nonzero, this function instruments the arcs in
+   When FLAG_PROFILE_ARCS is nonzero, this function instruments the edges in
    the flow graph that are needed to reconstruct the dynamic behavior of the
    flow graph.
 
    When FLAG_BRANCH_PROBABILITIES is nonzero, this function reads auxiliary
-   information from a data file containing arc count information from previous
+   information from a data file containing edge count information from previous
    executions of the function being compiled.  In this case, the flow graph is
    annotated with actual execution counts, which are later propagated into the
    rtl for optimization purposes.
@@ -741,688 +533,358 @@ compute_branch_probabilities (num_blocks, dump_file)
    Main entry point of this file.  */
 
 void
-branch_prob (f, dump_file)
-     rtx f;
-     FILE *dump_file;
+branch_prob ()
 {
-  int i, num_blocks;
-  struct adj_list *arcptr;
-  int num_arcs;
+  int i;
+  int num_edges;
+  struct edge_info *edge_infos;
+  struct edge_list *el;
 
-  /* start of a function.  */
+  /* Start of a function.  */
   if (flag_test_coverage)
     output_gcov_string (current_function_name, (long) -2);
 
-  /* Execute this only if doing arc profiling or branch probabilities.  */
-  if (! profile_arc_flag && ! flag_branch_probabilities
-      && ! flag_test_coverage)
-    abort ();
-
   total_num_times_called++;
 
-  /* Create an array label_to_bb of ints of size max_label_num.  */
-  label_to_bb_size = max_label_num ();
-  label_to_bb = (int *) oballoc (label_to_bb_size * sizeof (int));
-  bzero ((char *) label_to_bb, label_to_bb_size * sizeof (int));
-
-  /* Scan the insns in the function, count the number of basic blocks
-     present.  When a code label is passed, set label_to_bb[label] = bb
-     number.  */
+  /* We can't handle cyclic regions constructed using abnormal edges.
+     To avoid these we replace every source of abnormal edge by a fake
+     edge from entry node and every destination by fake edge to exit.
+     This keeps graph acyclic and our calculation exact for all normal
+     edges except for exit and entrance ones.
+   
+     We also add fake exit edges for each call and asm statement in the
+     basic, since it may not return.  */
 
-  /* The first block found will be block 1, so that function entry can be
-     block 0.  */
-
-  {
-    register RTX_CODE prev_code = JUMP_INSN;
-    register RTX_CODE code;
-    register rtx insn;
-    register int i;
-    int block_separator_emitted = 0;
-
-    ignore_next_note = 0;
-
-    for (insn = NEXT_INSN (f), i = 0; insn; insn = NEXT_INSN (insn))
-      {
-	code = GET_CODE (insn);
-
-	if (code == BARRIER)
-	  ;
-	else if (code == CODE_LABEL)
-	  /* This label is part of the next block, but we can't increment
-	     block number yet since there might be multiple labels.  */
-	  label_to_bb[CODE_LABEL_NUMBER (insn)] = i + 1;
-	/* We make NOTE_INSN_SETJMP notes into a block of their own, so that
-	   they can be the target of the fake arc for the setjmp call.
-	   This avoids creating cycles of fake arcs, which would happen if
-	   the block after the setjmp call contained a call insn.  */
-	else if ((prev_code == JUMP_INSN || prev_code == CALL_INSN
-		  || prev_code == CODE_LABEL || prev_code == BARRIER)
-		 && (GET_RTX_CLASS (code) == 'i'
-		     || (code == NOTE
-			 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP)))
-	  {
-	    i += 1;
-
-	    /* Emit the block separator if it hasn't already been emitted.  */
-	    if (flag_test_coverage && ! block_separator_emitted)
-	      {
-		/* Output a zero to the .bb file to indicate that a new
-		   block list is starting.  */
-		__write_long (0, bb_file, 4);
-	      }
-	    block_separator_emitted = 0;
-	  }
-	/* If flag_test_coverage is true, then we must add an entry to the
-	   .bb file for every note.  */
-	else if (code == NOTE && flag_test_coverage)
-	  {
-	    /* Must ignore the line number notes that immediately follow the
-	       end of an inline function to avoid counting it twice.  There
-	       is a note before the call, and one after the call.  */
-	    if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_REPEATED_LINE_NUMBER)
-	      ignore_next_note = 1;
-	    else if (NOTE_LINE_NUMBER (insn) > 0)
-	      {
-		if (ignore_next_note)
-		  ignore_next_note = 0;
-		else
-		  {
-		    /* Emit a block separator here to ensure that a NOTE
-		       immediately following a JUMP_INSN or CALL_INSN will end
-		       up in the right basic block list.  */
-		    if ((prev_code == JUMP_INSN || prev_code == CALL_INSN
-			 || prev_code == CODE_LABEL || prev_code == BARRIER)
-			&& ! block_separator_emitted)
-		      {
-			/* Output a zero to the .bb file to indicate that
-			   a new block list is starting.  */
-			__write_long (0, bb_file, 4);
-
-			block_separator_emitted = 1;
-		      }
-		    
-		    /* If this is a new source file, then output the file's
-		       name to the .bb file.  */
-		    if (! last_bb_file_name
-			|| strcmp (NOTE_SOURCE_FILE (insn),
-				   last_bb_file_name))
-		      {
-			if (last_bb_file_name)
-			  free (last_bb_file_name);
-			last_bb_file_name = xstrdup (NOTE_SOURCE_FILE (insn));
-			output_gcov_string (NOTE_SOURCE_FILE (insn), (long)-1);
-		      }
-
-		    /* Output the line number to the .bb file.  Must be done
-		       after the output_bb_profile_data() call, and after the
-		       file name is written, to ensure that it is correctly
-		       handled by gcov.  */
-		    __write_long (NOTE_LINE_NUMBER (insn), bb_file, 4);
-		  }
-	      }
-	  }
-
-	if (code != NOTE)
-	  prev_code = code;
-	else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP)
-	  prev_code = CALL_INSN;
-      }
-
-    /* Allocate last `normal' entry for bb_graph.  */
-
-    /* The last insn was a jump, call, or label.  In that case we have
-       a block at the end of the function with no insns.  */
-    if (prev_code == JUMP_INSN || prev_code == CALL_INSN
-	|| prev_code == CODE_LABEL || prev_code == BARRIER)
-      {
-	i++;
-
-	/* Emit the block separator if it hasn't already been emitted.  */
-	if (flag_test_coverage && ! block_separator_emitted)
-	  {
-	    /* Output a zero to the .bb file to indicate that a new
-	       block list is starting.  */
-	    __write_long (0, bb_file, 4);
-	  }
-      }
-
-    /* Create another block to stand for EXIT, and make all return insns, and
-       the last basic block point here.  Add one more to account for block
-       zero.  */
-    num_blocks = i + 2;
-  }
-
-  total_num_blocks += num_blocks;
-  if (dump_file)
-    fprintf (dump_file, "%d basic blocks\n", num_blocks);
-
-  /* If we are only doing test coverage here, then return now.  */
-  if (! profile_arc_flag && ! flag_branch_probabilities)
-    return;
-
-  /* Create and initialize the arrays that will hold bb_graph
-     and execution count info.  */
-
-  bb_graph = (struct bb_info *) xcalloc (num_blocks, 
-					 sizeof (struct bb_info));
+  for (i = 0; i < n_basic_blocks ; i++)
+    {
+      rtx insn;
+      int need_exit_edge = 0, need_entry_edge = 0;
+      int have_exit_edge = 0, have_entry_edge = 0;
+      basic_block bb = BASIC_BLOCK (i);
+      edge e;
 
-  {
-    /* Scan the insns again:
-       - at the entry to each basic block, increment the predecessor count
-       (and successor of previous block) if it is a fall through entry,
-       create adj_list entries for this and the previous block
-       - at each jump insn, increment predecessor/successor counts for
-       target/source basic blocks, add this insn to pred/succ lists.
-
-       This also cannot be broken out as a separate subroutine
-       because it uses `alloca'.  */
-
-    register RTX_CODE prev_code = JUMP_INSN;
-    register RTX_CODE code;
-    register rtx insn;
-    register int i;
-    int fall_through = 0;
-    struct adj_list *arcptr;
-    int dest = 0;
-
-    /* Block 0 always falls through to block 1.  */
-    num_arcs = 0;
-    arcptr = (struct adj_list *) alloca (sizeof (struct adj_list));
-    init_arc (arcptr, 0, 1, 0);
-    arcptr->fall_through = 1;
-    num_arcs++;
-
-    /* Add a fake fall through arc from the last block to block 0, to make the
-       graph complete.  */
-    arcptr = (struct adj_list *) alloca (sizeof (struct adj_list));
-    init_arc (arcptr, num_blocks - 1, 0, 0);
-    arcptr->fake = 1;
-    num_arcs++;
-
-    /* Exit must be one node of the graph, and all exits from the function
-       must point there.  When see a return branch, must point the arc to the
-       exit node.  */
-
-    /* Must start scan with second insn in function as above.  */
-    for (insn = NEXT_INSN (f), i = 0; insn; insn = NEXT_INSN (insn))
-      {
-	code = GET_CODE (insn);
-
-	if (code == BARRIER)
-	  fall_through = 0;
-	else if (code == CODE_LABEL)
-	  ;
-	/* We make NOTE_INSN_SETJMP notes into a block of their own, so that
-	   they can be the target of the fake arc for the setjmp call.
-	   This avoids creating cycles of fake arcs, which would happen if
-	   the block after the setjmp call ended with a call.  */
-	else if ((prev_code == JUMP_INSN || prev_code == CALL_INSN
-		  || prev_code == CODE_LABEL || prev_code == BARRIER)
-		 && (GET_RTX_CLASS (code) == 'i'
-		     || (code == NOTE
-			 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP)))
-	  {
-	    /* This is the first insn of the block.  */
-	    i += 1;
-	    if (fall_through)
-	      {
-		arcptr = (struct adj_list *) alloca (sizeof (struct adj_list));
-		init_arc (arcptr, i - 1, i, 0);
-		arcptr->fall_through = 1;
+      for (e = bb->succ; e; e = e->succ_next)
+	{
+	  if ((e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL))
+	       && e->dest != EXIT_BLOCK_PTR)
+	    need_exit_edge = 1;
+	  if (e->dest == EXIT_BLOCK_PTR)
+	    have_exit_edge = 1;
+	}
+      for (e = bb->pred; e; e = e->pred_next)
+	{
+	  if ((e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL))
+	       && e->src != ENTRY_BLOCK_PTR)
+	    need_entry_edge = 1;
+	  if (e->src == ENTRY_BLOCK_PTR)
+	    have_entry_edge = 1;
+	}
 
-		num_arcs++;
-	      }
-	    fall_through = 1;
-	    bb_graph[i].first_insn = insn;
-	  }
-	else if (code == NOTE)
-	  {;}
+      /* ??? Not strictly needed unless flag_test_coverage, but adding
+	 them anyway keeps the .da file consistent.  */
+      /* ??? Currently inexact for basic blocks with multiple calls. 
+	 We need to split blocks here.  */
+      for (insn = bb->head;
+	   insn != NEXT_INSN (bb->end);
+	   insn = NEXT_INSN (insn))
+	{
+	  rtx set;
+	  if (GET_CODE (insn) == CALL_INSN && !CONST_CALL_P (insn))
+	    need_exit_edge = 1;
+	  else if (GET_CODE (insn) == INSN)
+	    {
+	      set = PATTERN (insn);
+	      if (GET_CODE (set) == PARALLEL)
+		set = XVECEXP (set, 0, 0);
+	      if ((GET_CODE (set) == ASM_OPERANDS && MEM_VOLATILE_P (set))
+		  || GET_CODE (set) == ASM_INPUT)
+		need_exit_edge = 1;
+	    }
+	}
 
-	if (code == CALL_INSN)
-	  {
-	    /* In the normal case, the call returns, and this is just like
-	       a branch fall through.  */
-	    fall_through = 1;
-
-	    /* Setjmp may return more times than called, so to make the graph
-	       solvable, add a fake arc from the function entrance to the
-	       next block.
-
-	       All other functions may return fewer times than called (if
-	       a descendent call longjmp or exit), so to make the graph
-	       solvable, add a fake arc to the function exit from the
-	       current block.
-
-	       Distinguish the cases by checking for a SETJUMP note.
-	       A call_insn can be the last ins of a function, so must check
-	       to see if next insn actually exists.  */
-	    arcptr = (struct adj_list *) alloca (sizeof (struct adj_list));
-	    if (NEXT_INSN (insn)
-		&& GET_CODE (NEXT_INSN (insn)) == NOTE
-		&& NOTE_LINE_NUMBER (NEXT_INSN (insn)) == NOTE_INSN_SETJMP)
-	      init_arc (arcptr, 0, i+1, insn);
-	    else
-	      init_arc (arcptr, i, num_blocks-1, insn);
-	    arcptr->fake = 1;
-	    num_arcs++;
-	  }
-	else if (code == JUMP_INSN)
-	  {
-	    rtx tem, pattern = PATTERN (insn);
-	    rtx tablejump = 0;
-
-	    /* If running without optimization, then jump label won't be valid,
-	       so we must search for the destination label in that case.
-	       We have to handle tablejumps and returns specially anyways, so
-	       we don't check the JUMP_LABEL at all here.  */
-
-	    /* ??? This code should be rewritten.  We need a more elegant way
-	       to find the LABEL_REF.  We need a more elegant way to
-	       differentiate tablejump entries from computed gotos.
-	       We should perhaps reuse code from flow to compute the CFG
-	       instead of trying to compute it here.
-
-	       We can't use current_function_has_computed_jump, because that
-	       is calculated later by flow.  We can't use computed_jump_p,
-	       because that returns true for tablejump entry insns for some
-	       targets, e.g. HPPA and MIPS.  */
-
-	    if (GET_CODE (pattern) == PARALLEL)
-	      {
-		/* This assumes that PARALLEL jumps with a USE are
-		   tablejump entry jumps.  The same assumption can be found
-		   in computed_jump_p.  */
-		/* Make an arc from this jump to the label of the
-		   jump table.  This will instrument the number of
-		   times the switch statement is executed.  */
-		if (GET_CODE (XVECEXP (pattern, 0, 1)) == USE)
-		  {
-		    tem = XEXP (XVECEXP (pattern, 0, 1), 0);
-		    if (GET_CODE (tem) != LABEL_REF)
-		      abort ();
-		    dest = label_to_bb[CODE_LABEL_NUMBER (XEXP (tem, 0))];
-		  }
-		else if (GET_CODE (XVECEXP (pattern, 0, 0)) == SET
-			 && SET_DEST (XVECEXP (pattern, 0, 0)) == pc_rtx)
-		  {
-		    tem = SET_SRC (XVECEXP (pattern, 0, 0));
-		    if (GET_CODE (tem) == PLUS
-			&& GET_CODE (XEXP (tem, 1)) == LABEL_REF)
-		      {
-			tem = XEXP (tem, 1);
-			dest = label_to_bb [CODE_LABEL_NUMBER (XEXP (tem, 0))];
-		      }
-		  }
-		else
-		  abort ();
-	      }
-	    else if (GET_CODE (pattern) == ADDR_VEC
-		     || GET_CODE (pattern) == ADDR_DIFF_VEC)
-	      tablejump = pattern;
-	    else if (GET_CODE (pattern) == RETURN)
-	      dest = num_blocks - 1;
-	    else if (GET_CODE (pattern) != SET)
-	      abort ();
-	    else if ((tem = SET_SRC (pattern))
-		     && GET_CODE (tem) == LABEL_REF)
-	      dest = label_to_bb[CODE_LABEL_NUMBER (XEXP (tem, 0))];
-	    /* Recognize HPPA table jump entry.  This code is similar to
-	       the code above in the PARALLEL case.  */
-	    else if (GET_CODE (tem) == PLUS
-		     && GET_CODE (XEXP (tem, 0)) == MEM
-		     && GET_CODE (XEXP (XEXP (tem, 0), 0)) == PLUS
-		     && GET_CODE (XEXP (XEXP (XEXP (tem, 0), 0), 0)) == PC
-		     && GET_CODE (XEXP (tem, 1)) == LABEL_REF
-		     && tablejump_entry_p (insn, XEXP (tem, 1)))
-	      dest = label_to_bb[CODE_LABEL_NUMBER (XEXP (XEXP (tem, 1), 0))];
-	    /* Recognize the MIPS table jump entry.  */
-	    else if (GET_CODE (tem) == PLUS
-		     && GET_CODE (XEXP (tem, 0)) == REG
-		     && GET_CODE (XEXP (tem, 1)) == LABEL_REF
-		     && tablejump_entry_p (insn, XEXP (tem, 1)))
-	      dest = label_to_bb[CODE_LABEL_NUMBER (XEXP (XEXP (tem, 1), 0))];
-	    else
-	      {
-		rtx label_ref;
-
-		/* Must be an IF_THEN_ELSE branch.  If it isn't, assume it
-		   is a computed goto, which aren't supported yet.  */
-		if (GET_CODE (tem) != IF_THEN_ELSE)
-		  fatal ("-fprofile-arcs does not support computed gotos");
-		if (XEXP (tem, 1) != pc_rtx)
-		  label_ref = XEXP (tem, 1);
-		else
-		  label_ref = XEXP (tem, 2);
-		dest = label_to_bb[CODE_LABEL_NUMBER (XEXP (label_ref, 0))];
-	      }
+      if (need_exit_edge && !have_exit_edge)
+	{
+	  if (rtl_dump_file)
+	    fprintf (rtl_dump_file, "Adding fake exit edge to bb %i\n",
+		     bb->index);
+          make_edge (NULL, bb, EXIT_BLOCK_PTR, EDGE_FAKE);
+	}
+      if (need_entry_edge && !have_entry_edge)
+	{
+	  if (rtl_dump_file)
+	    fprintf (rtl_dump_file, "Adding fake entry edge to bb %i\n",
+		     bb->index);
+          make_edge (NULL, ENTRY_BLOCK_PTR, bb, EDGE_FAKE);
+	}
+    }
 
-	    if (tablejump)
-	      {
-		int diff_vec_p = GET_CODE (tablejump) == ADDR_DIFF_VEC;
-		int len = XVECLEN (tablejump, diff_vec_p);
-		int k;
+  el = create_edge_list ();
+  num_edges = NUM_EDGES (el);
+  edge_infos = (struct edge_info *)
+    xcalloc (num_edges, sizeof (struct edge_info));
 
-		for (k = 0; k < len; k++)
-		  {
-		    rtx tem = XEXP (XVECEXP (tablejump, diff_vec_p, k), 0);
-		    dest = label_to_bb[CODE_LABEL_NUMBER (tem)];
+  for (i = 0 ; i < num_edges ; i++)
+    {
+      edge e = INDEX_EDGE (el, i);
+      e->count = 0;
+      e->aux = &edge_infos[i];
+
+      /* Mark edges we've replaced by fake edges above as ignored.  */
+      if ((e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL))
+	  && e->src != ENTRY_BLOCK_PTR && e->dest != EXIT_BLOCK_PTR)
+	EDGE_INFO (e)->ignore = 1;
+    }
 
-		    arcptr = (struct adj_list *) alloca (sizeof(struct adj_list));
-		    init_arc (arcptr, i, dest, insn);
+  total_num_blocks += n_basic_blocks + 2;
+  if (rtl_dump_file)
+    fprintf (rtl_dump_file, "%d basic blocks\n", n_basic_blocks);
 
-		    num_arcs++;
-		  }
-	      }
-	    else
-	      {
-		arcptr = (struct adj_list *) alloca (sizeof (struct adj_list));
-		init_arc (arcptr, i, dest, insn);
+  total_num_edges += num_edges;
+  if (rtl_dump_file)
+    fprintf (rtl_dump_file, "%d edges\n", num_edges);
 
-		num_arcs++;
-	      }
+#ifdef ENABLE_CHECKING
+  verify_flow_info ();
+#endif
 
-	    /* Determine whether or not this jump will fall through.
-	       Unconditional jumps and returns are not always followed by
-	       barriers.  */
-	    pattern = PATTERN (insn);
-	    if (GET_CODE (pattern) == PARALLEL
-		|| GET_CODE (pattern) == RETURN)
-	      fall_through = 0;
-	    else if (GET_CODE (pattern) == ADDR_VEC
-		     || GET_CODE (pattern) == ADDR_DIFF_VEC)
-	      /* These aren't actually jump insns, but they never fall
-		 through, so...  */
-	      fall_through = 0;
-	    else
-	      {
-		if (GET_CODE (pattern) != SET || SET_DEST (pattern) != pc_rtx)
-		  abort ();
-		if (GET_CODE (SET_SRC (pattern)) != IF_THEN_ELSE)
-		  fall_through = 0;
-	      }
-	  }
+  /* Output line number information about each basic block for
+     GCOV utility.  */
+  if (flag_test_coverage)
+    {
+      int i = 0;
+      for (i = 0 ; i < n_basic_blocks; i++)
+        {
+	  basic_block bb = BASIC_BLOCK (i);
+	  rtx insn = bb->head;
+          static int ignore_next_note = 0;
+
+	  /* We are looking for line number notes.  Search backward before
+	     basic block to find correct ones.  */
+	  insn = prev_nonnote_insn (insn);
+	  if (!insn)
+	    insn = get_insns ();
+	  else
+	    insn = NEXT_INSN (insn);
 
-	if (code != NOTE)
-	  prev_code = code;
-	else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP)
-	  {
-	    /* Make a fake insn to tag our notes on.  */
-	    bb_graph[i].first_insn = insn
-	      = emit_insn_after (gen_rtx_USE (VOIDmode, stack_pointer_rtx),
-				 insn);
-	    prev_code = CALL_INSN;
-	  }
-      }
+	  /* Output a zero to the .bb file to indicate that a new
+	     block list is starting.  */
+	  __write_long (0, bb_file, 4);
 
-    /* If the code at the end of the function would give a new block, then
-       do the following.  */
+	  while (insn != bb->end)
+	    {
+	      if (GET_CODE (insn) == NOTE)
+		{
+		  /* Must ignore the line number notes that immediately
+		     follow the end of an inline function to avoid counting
+		     it twice.  There is a note before the call, and one
+		     after the call.  */
+		  if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_REPEATED_LINE_NUMBER)
+		    ignore_next_note = 1;
+		  else if (NOTE_LINE_NUMBER (insn) > 0)
+		    {
+		      if (ignore_next_note)
+			ignore_next_note = 0;
+		      else
+			{
+			  /* If this is a new source file, then output the
+			     file's name to the .bb file.  */
+			  if (! last_bb_file_name
+			      || strcmp (NOTE_SOURCE_FILE (insn),
+					 last_bb_file_name))
+			    {
+			      if (last_bb_file_name)
+				free (last_bb_file_name);
+			      last_bb_file_name
+				= xstrdup (NOTE_SOURCE_FILE (insn));
+			      output_gcov_string (NOTE_SOURCE_FILE (insn),
+						  (long)-1);
+			    }
+			  /* Output the line number to the .bb file.  Must be
+			     done after the output_bb_profile_data() call, and
+			     after the file name is written, to ensure that it
+			     is correctly handled by gcov.  */
+			  __write_long (NOTE_LINE_NUMBER (insn), bb_file, 4);
+			}
+		    }
+		}
+	      insn = NEXT_INSN (insn);
+	    }
+        }
+      __write_long (0, bb_file, 4);
+    }
 
-    if (prev_code == JUMP_INSN || prev_code == CALL_INSN
-	|| prev_code == CODE_LABEL || prev_code == BARRIER)
-      {
-	if (fall_through)
-	  {
-	    arcptr = (struct adj_list *) alloca (sizeof (struct adj_list));
-	    init_arc (arcptr, i, i + 1, 0);
-	    arcptr->fall_through = 1;
+  /* Create spanning tree from basic block graph, mark each edge that is
+     on the spanning tree.  We insert as many abnormal and critical edges
+     as possible to minimize number of edge splits necesary. */
 
-	    num_arcs++;
-	  }
-	  
-	/* This may not be a real insn, but that should not cause a problem.  */
-	bb_graph[i+1].first_insn = get_last_insn ();
-      }
-
-    /* There is always a fake arc from the last block of the function
-       to the function exit block.  */
-    arcptr = (struct adj_list *) alloca (sizeof (struct adj_list));
-    init_arc (arcptr, num_blocks-2, num_blocks-1, 0);
-    arcptr->fake = 1;
-    num_arcs++;
-  }
-
-  total_num_arcs += num_arcs;
-  if (dump_file)
-    fprintf (dump_file, "%d arcs\n", num_arcs);
-
-  /* Create spanning tree from basic block graph, mark each arc that is
-     on the spanning tree.  */
-
-  /* To reduce the instrumentation cost, make two passes over the tree.
-     First, put as many must-split (crowded and fake) arcs on the tree as
-     possible, then on the second pass fill in the rest of the tree.
-     Note that the spanning tree is considered undirected, so that as many
-     must-split arcs as possible can be put on it.
-
-     Fallthrough arcs which are crowded should not be chosen on the first
-     pass, since they do not require creating a new basic block.  These
-     arcs will have fall_through set.  */
-
-  find_spanning_tree (num_blocks);
+  find_spanning_tree (el);
 
   /* Create a .bbg file from which gcov can reconstruct the basic block
      graph.  First output the number of basic blocks, and then for every
-     arc output the source and target basic block numbers.
+     edge output the source and target basic block numbers.
      NOTE: The format of this file must be compatible with gcov.  */
 
   if (flag_test_coverage)
     {
       int flag_bits;
 
-      __write_long (num_blocks, bbg_file, 4);
-      __write_long (num_arcs, bbg_file, 4);
+      /* The plus 2 stands for entry and exit block.  */
+      __write_long (n_basic_blocks + 2, bbg_file, 4);
+      __write_long (num_edges + 1, bbg_file, 4);
 
-      for (i = 0; i < num_blocks; i++)
+      for (i = 0; i < n_basic_blocks + 1; i++)
 	{
+	  basic_block bb = GCOV_INDEX_TO_BB (i);
+	  edge e;
 	  long count = 0;
-	  for (arcptr = bb_graph[i].succ; arcptr; arcptr = arcptr->succ_next)
-	    count++;
+
+	  for (e = bb->succ; e; e = e->succ_next)
+	    if (!EDGE_INFO (e)->ignore)
+	      count++;
 	  __write_long (count, bbg_file, 4);
 
-	  for (arcptr = bb_graph[i].succ; arcptr; arcptr = arcptr->succ_next)
+	  for (e = bb->succ; e; e = e->succ_next)
 	    {
-	      flag_bits = 0;
-	      if (arcptr->on_tree)
-		flag_bits |= 0x1;
-	      if (arcptr->fake)
-		flag_bits |= 0x2;
-	      if (arcptr->fall_through)
-		flag_bits |= 0x4;
-
-	      __write_long (ARC_TARGET (arcptr), bbg_file, 4);
-	      __write_long (flag_bits, bbg_file, 4);
+	      struct edge_info *i = EDGE_INFO (e);
+	      if (!i->ignore)
+		{
+		  flag_bits = 0;
+		  if (i->on_tree)
+		    flag_bits |= 0x1;
+		  if (e->flags & EDGE_ABNORMAL)
+		    flag_bits |= 0x2;
+		  if (e->flags & EDGE_FALLTHRU)
+		    flag_bits |= 0x4;
+
+		  __write_long (BB_TO_GCOV_INDEX (e->dest), bbg_file, 4);
+		  __write_long (flag_bits, bbg_file, 4);
+	        }
 	    }
 	}
+      /* Emit fake loopback edge for EXIT block to maitain compatibility with
+         old gcov format.  */
+      __write_long (1, bbg_file, 4);
+      __write_long (0, bbg_file, 4);
+      __write_long (0x1, bbg_file, 4);
 
-      /* Emit a -1 to separate the list of all arcs from the list of
+      /* Emit a -1 to separate the list of all edges from the list of
 	 loop back edges that follows.  */
       __write_long (-1, bbg_file, 4);
     }
 
-  /* For each arc not on the spanning tree, add counting code as rtl.  */
+  if (flag_branch_probabilities)
+    compute_branch_probabilities ();
+
+  /* For each edge not on the spanning tree, add counting code as rtl.  */
 
   if (profile_arc_flag)
     {
-      instrument_arcs (f, num_blocks, dump_file);
+      instrument_edges (el);
       allocate_reg_info (max_reg_num (), FALSE, FALSE);
     }
 
-  /* Execute the rest only if doing branch probabilities.  */
-  if (flag_branch_probabilities)
-    compute_branch_probabilities (num_blocks, dump_file);
-
-  /* Clean up.  */
-  free (bb_graph);
+  remove_fake_edges ();
+  free (edge_infos);
+  free_edge_list (el);
 }
 
-/* Initialize a new arc.
-   ARCPTR is the empty adj_list this function fills in.
-   SOURCE is the block number of the source block.
-   TARGET is the block number of the target block.
-   INSN is the insn which transfers control from SOURCE to TARGET,
-   or zero if the transfer is implicit.  */
+/* Union find algorithm implementation for the basic blocks using
+   aux fields. */
 
-static void
-init_arc (arcptr, source, target, insn)
-     struct adj_list *arcptr;
-     int source, target;
-     rtx insn;
+static basic_block
+find_group (bb)
+     basic_block bb;
 {
-  ARC_TARGET (arcptr) = target;
-  ARC_SOURCE (arcptr) = source;
-
-  ARC_COUNT (arcptr) = 0;
-  arcptr->count_valid = 0;
-  arcptr->on_tree = 0;
-  arcptr->fake = 0;
-  arcptr->fall_through = 0;
-  arcptr->branch_insn = insn;
-
-  arcptr->succ_next = bb_graph[source].succ;
-  bb_graph[source].succ = arcptr;
-  bb_graph[source].succ_count++;
-
-  arcptr->pred_next = bb_graph[target].pred;
-  bb_graph[target].pred = arcptr;
-  bb_graph[target].pred_count++;
-}
+  basic_block group = bb, bb1;
 
-/* This function searches all of the arcs in the program flow graph, and puts
-   as many bad arcs as possible onto the spanning tree.  Bad arcs include
-   fake arcs (needed for setjmp(), longjmp(), exit()) which MUST be on the
-   spanning tree as they can't be instrumented.  Also, arcs which must be
-   split when instrumented should be part of the spanning tree if possible.  */
+  while ((basic_block) group->aux != group)
+    group = (basic_block) group->aux;
 
-static void
-find_spanning_tree (num_blocks)
-     int num_blocks;
-{
-  int i;
-  struct adj_list *arcptr;
-  struct bb_info *binfo = &bb_graph[0];
-
-  /* Fake arcs must be part of the spanning tree, and are always safe to put
-     on the spanning tree.  Fake arcs will either be a successor of node 0,
-     a predecessor of the last node, or from the last node to node 0.  */
-
-  for (arcptr = bb_graph[0].succ; arcptr; arcptr = arcptr->succ_next)
-    if (arcptr->fake)
-      {
-	/* Adding this arc should never cause a cycle.  This is a fatal 
-	   error if it would.  */
-	if (bb_graph[ARC_TARGET (arcptr)].on_tree && binfo->on_tree)
-	  abort();
-	else
-	  {
-	    arcptr->on_tree = 1;
-	    bb_graph[ARC_TARGET (arcptr)].on_tree = 1;
-	    binfo->on_tree = 1;
-	  }
-      }
-
-  binfo = &bb_graph[num_blocks-1];
-  for (arcptr = binfo->pred; arcptr; arcptr = arcptr->pred_next)
-    if (arcptr->fake)
-      {
-	/* Adding this arc should never cause a cycle.  This is a fatal 
-	   error if it would.  */
-	if (bb_graph[ARC_SOURCE (arcptr)].on_tree && binfo->on_tree)
-	  abort();
-	else
-	  {
-	    arcptr->on_tree = 1;
-	    bb_graph[ARC_SOURCE (arcptr)].on_tree = 1;
-	    binfo->on_tree = 1;
-	  }
-      }
-  /* The only entrace to node zero is a fake arc.  */
-  bb_graph[0].pred->on_tree = 1;
-  
-  /* Arcs which are crowded at both the source and target should be put on
-     the spanning tree if possible, except for fall_throuch arcs which never
-     require adding a new block even if crowded, add arcs with the same source
-     and dest which must always be instrumented.  */
-  for (i = 0; i < num_blocks; i++)
+  /* Compress path.  */
+  while ((basic_block) bb->aux != group)
     {
-      binfo = &bb_graph[i];
-
-      for (arcptr = binfo->succ; arcptr; arcptr = arcptr->succ_next)
-	if (! ((binfo->succ == arcptr && arcptr->succ_next == 0)
-	       || (bb_graph[ARC_TARGET (arcptr)].pred
-		   && arcptr->pred_next == 0))
-	    && ! arcptr->fall_through
-	    && ARC_TARGET (arcptr) != i)
-	  {
-	    /* This is a crowded arc at both source and target.  Try to put
-	       in on the spanning tree.  Can do this if either the source or
-	       target block is not yet on the tree.  */
-	    if (! bb_graph[ARC_TARGET (arcptr)].on_tree	|| ! binfo->on_tree)
-	      {
-		arcptr->on_tree = 1;
-		bb_graph[ARC_TARGET (arcptr)].on_tree = 1;
-		binfo->on_tree = 1;
-	      }
-	  }
+      bb1 = (basic_block) bb->aux;
+      bb->aux = (void *) group;
+      bb = bb1;
     }
+  return group;
+}
 
-  /* Clear all of the basic block on_tree bits, so that we can use them to
-     create the spanning tree.  */
-  for (i = 0; i < num_blocks; i++)
-    bb_graph[i].on_tree = 0;
+static void
+union_groups (bb1, bb2)
+     basic_block bb1, bb2;
+{
+  basic_block bb1g = find_group (bb1);
+  basic_block bb2g = find_group (bb2);
 
-  /* Now fill in the spanning tree until every basic block is on it.
-     Don't put the 0 to 1 fall through arc on the tree, since it is 
-     always cheap to instrument, so start filling the tree from node 1.  */
+  /* ??? I don't have a place for the rank field.  OK.  Lets go w/o it,
+     this code is unlikely going to be performance problem anyway.  */
+  if (bb1g == bb2g)
+    abort ();
 
-  for (i = 1; i < num_blocks; i++)
-    for (arcptr = bb_graph[i].succ; arcptr; arcptr = arcptr->succ_next)
-      if (! arcptr->on_tree
-	  && ! bb_graph[ARC_TARGET (arcptr)].on_tree)
-	{
-	  fill_spanning_tree (i);
-	  break;
-	}
+  bb1g->aux = bb2g;
 }
-
-/* Add arcs reached from BLOCK to the spanning tree if they are needed and
-   not already there.  */
+
+/* This function searches all of the edges in the program flow graph, and puts
+   as many bad edges as possible onto the spanning tree.  Bad edges include
+   abnormals edges, which can't be instrumented at the moment.  Since it is
+   possible for fake edges to form an cycle, we will have to develop some
+   better way in the future.  Also put critical edges to the tree, since they
+   are more expensive to instrument.  */
 
 static void
-fill_spanning_tree (block)
-     int block;
+find_spanning_tree (el)
+     struct edge_list *el;
 {
-  struct adj_list *arcptr;
-  
-  expand_spanning_tree (block);
-
-  for (arcptr = bb_graph[block].succ; arcptr; arcptr = arcptr->succ_next)
-    if (! arcptr->on_tree
-	&& ! bb_graph[ARC_TARGET (arcptr)].on_tree)
-      {
-	arcptr->on_tree = 1;
-	fill_spanning_tree (ARC_TARGET (arcptr));
-      }
-}
+  int i;
+  int num_edges = NUM_EDGES (el);
 
-/* When first visit a block, must add all blocks that are already connected
-   to this block via tree arcs to the spanning tree.  */
+  /* We use aux field for standard union-find algorithm.  */
+  EXIT_BLOCK_PTR->aux = EXIT_BLOCK_PTR;
+  ENTRY_BLOCK_PTR->aux = ENTRY_BLOCK_PTR;
+  for (i = 0; i < n_basic_blocks; i++)
+    BASIC_BLOCK (i)->aux = BASIC_BLOCK (i);
 
-static void
-expand_spanning_tree (block)
-     int block;
-{
-  struct adj_list *arcptr;
-
-  bb_graph[block].on_tree = 1;
-
-  for (arcptr = bb_graph[block].succ; arcptr; arcptr = arcptr->succ_next)
-    if (arcptr->on_tree && ! bb_graph[ARC_TARGET (arcptr)].on_tree)
-      expand_spanning_tree (ARC_TARGET (arcptr));
-    
-  for (arcptr = bb_graph[block].pred;
-       arcptr; arcptr = arcptr->pred_next)
-    if (arcptr->on_tree && ! bb_graph[ARC_SOURCE (arcptr)].on_tree)
-      expand_spanning_tree (ARC_SOURCE (arcptr));
+  /* Add fake edge exit to entry we can't instrument.  */
+  union_groups (EXIT_BLOCK_PTR, ENTRY_BLOCK_PTR);
+
+  /* First add all abnormal edges to the tree unless they form an cycle.  */
+  for (i = 0; i < num_edges; i++)
+    {
+      edge e = INDEX_EDGE (el, i);
+      if ((e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_FAKE))
+	  && !EDGE_INFO (e)->ignore
+	  && (find_group (e->src) != find_group (e->dest)))
+	{
+	  EDGE_INFO (e)->on_tree = 1;
+	  union_groups (e->src, e->dest);
+	}
+    }
+
+  /* Now insert all critical edges to the tree unless they form an cycle.  */
+  for (i = 0; i < num_edges; i++)
+    {
+      edge e = INDEX_EDGE (el, i);
+      if ((e->flags & EDGE_CRITICAL)
+	  && !EDGE_INFO (e)->ignore
+	  && (find_group (e->src) != find_group (e->dest)))
+	{
+	  EDGE_INFO (e)->on_tree = 1;
+	  union_groups (e->src, e->dest);
+	}
+    }
+
+  /* And now the rest.  */
+  for (i = 0; i < num_edges; i++)
+    {
+      edge e = INDEX_EDGE (el, i);
+      if (find_group (e->src) != find_group (e->dest)
+	  && !EDGE_INFO (e)->ignore)
+	{
+	  EDGE_INFO (e)->on_tree = 1;
+	  union_groups (e->src, e->dest);
+	}
+    }
 }
 
 /* Perform file-level initialization for branch-prob processing.  */
@@ -1436,9 +898,11 @@ init_branch_prob (filename)
 
   if (flag_test_coverage)
     {
-      /* Open an output file for the basic block/line number map.  */
       int len = strlen (filename);
-      char *data_file = (char *) alloca (len + 4);
+      char *data_file, *bbg_file_name;
+
+      /* Open an output file for the basic block/line number map.  */
+      data_file = (char *) alloca (len + 4);
       strcpy (data_file, filename);
       strip_off_ending (data_file, len);
       strcat (data_file, ".bb");
@@ -1446,7 +910,6 @@ init_branch_prob (filename)
 	pfatal_with_name (data_file);
 
       /* Open an output file for the program flow graph.  */
-      len = strlen (filename);
       bbg_file_name = (char *) alloca (len + 5);
       strcpy (bbg_file_name, filename);
       strip_off_ending (bbg_file_name, len);
@@ -1461,6 +924,8 @@ init_branch_prob (filename)
 
   if (flag_branch_probabilities)
     {
+      char *da_file_name;
+
       len = strlen (filename);
       da_file_name = (char *) alloca (len + 4);
       strcpy (da_file_name, filename);
@@ -1470,19 +935,19 @@ init_branch_prob (filename)
 	warning ("file %s not found, execution counts assumed to be zero.",
 		 da_file_name);
 
-      /* The first word in the .da file gives the number of instrumented arcs,
-	 which is not needed for our purposes.  */
+      /* The first word in the .da file gives the number of instrumented
+	 edges, which is not needed for our purposes.  */
 
       if (da_file)
 	__read_long (&len, da_file, 8);
     }
 
   if (profile_arc_flag)
-    init_arc_profiler ();
+    init_edge_profiler ();
 
   total_num_blocks = 0;
-  total_num_arcs = 0;
-  total_num_arcs_instrumented = 0;
+  total_num_edges = 0;
+  total_num_edges_instrumented = 0;
   total_num_blocks_created = 0;
   total_num_passes = 0;
   total_num_times_called = 0;
@@ -1496,8 +961,7 @@ init_branch_prob (filename)
    is completed.  */
 
 void
-end_branch_prob (dump_file)
-     FILE *dump_file;
+end_branch_prob ()
 {
   if (flag_test_coverage)
     {
@@ -1522,44 +986,46 @@ end_branch_prob (dump_file)
 	}
     }
 
-  if (dump_file)
+  if (rtl_dump_file)
     {
-      fprintf (dump_file, "\n");
-      fprintf (dump_file, "Total number of blocks: %d\n", total_num_blocks);
-      fprintf (dump_file, "Total number of arcs: %d\n", total_num_arcs);
-      fprintf (dump_file, "Total number of instrumented arcs: %d\n",
-	       total_num_arcs_instrumented);
-      fprintf (dump_file, "Total number of blocks created: %d\n",
+      fprintf (rtl_dump_file, "\n");
+      fprintf (rtl_dump_file, "Total number of blocks: %d\n",
+	       total_num_blocks);
+      fprintf (rtl_dump_file, "Total number of edges: %d\n", total_num_edges);
+      fprintf (rtl_dump_file, "Total number of instrumented edges: %d\n",
+	       total_num_edges_instrumented);
+      fprintf (rtl_dump_file, "Total number of blocks created: %d\n",
 	       total_num_blocks_created);
-      fprintf (dump_file, "Total number of graph solution passes: %d\n",
+      fprintf (rtl_dump_file, "Total number of graph solution passes: %d\n",
 	       total_num_passes);
       if (total_num_times_called != 0)
-	fprintf (dump_file, "Average number of graph solution passes: %d\n",
+	fprintf (rtl_dump_file, "Average number of graph solution passes: %d\n",
 		 (total_num_passes + (total_num_times_called  >> 1))
 		 / total_num_times_called);
-      fprintf (dump_file, "Total number of branches: %d\n", total_num_branches);
-      fprintf (dump_file, "Total number of branches never executed: %d\n",
+      fprintf (rtl_dump_file, "Total number of branches: %d\n",
+	       total_num_branches);
+      fprintf (rtl_dump_file, "Total number of branches never executed: %d\n",
 	       total_num_never_executed);
       if (total_num_branches)
 	{
 	  int i;
 
 	  for (i = 0; i < 10; i++)
-	    fprintf (dump_file, "%d%% branches in range %d-%d%%\n",
+	    fprintf (rtl_dump_file, "%d%% branches in range %d-%d%%\n",
 		     (total_hist_br_prob[i] + total_hist_br_prob[19-i]) * 100
 		     / total_num_branches, 5*i, 5*i+5);
 	}
     }
 }
 
-/* The label used by the arc profiling code.  */
+/* The label used by the edge profiling code.  */
 
 static rtx profiler_label;
 
 /* Initialize the profiler_label.  */
 
 static void
-init_arc_profiler ()
+init_edge_profiler ()
 {
   /* Generate and save a copy of this so it can be shared.  */
   char *name = ggc_alloc_string (NULL, 20);
@@ -1568,84 +1034,31 @@ init_arc_profiler ()
   ggc_add_rtx_root (&profiler_label, 1);
 }
 
-/* Output instructions as RTL to increment the arc execution count.  */
+/* Output instructions as RTL to increment the edge execution count.  */
 
-static void
-output_arc_profiler (arcno, insert_after)
-     int arcno;
-     rtx insert_after;
+static rtx
+gen_edge_profiler (edgeno)
+     int edgeno;
 {
-  rtx profiler_target_addr
-    = (arcno ? plus_constant (profiler_label,
-			      LONG_TYPE_SIZE / BITS_PER_UNIT * arcno)
-       : profiler_label);
   enum machine_mode mode = mode_for_size (LONG_TYPE_SIZE, MODE_INT, 0);
-  rtx profiler_reg = gen_reg_rtx (mode);
-  rtx address_reg = gen_reg_rtx (Pmode);
-  rtx mem_ref, add_ref;
+  rtx mem_ref, tmp;
   rtx sequence;
 
-  /* In this case, reload can use explicitly mentioned hard registers for
-     reloads.  It is not safe to output profiling code between a call
-     and the instruction that copies the result to a pseudo-reg.  This
-     is because reload may allocate one of the profiling code pseudo-regs
-     to the return value reg, thus clobbering the return value.  So we
-     must check for calls here, and emit the profiling code after the
-     instruction that uses the return value, if any.
-
-     ??? The code here performs the same tests that reload does so hopefully
-     all the bases are covered.  */
-
-  if (SMALL_REGISTER_CLASSES
-      && GET_CODE (insert_after) == CALL_INSN
-      && (GET_CODE (PATTERN (insert_after)) == SET
-	  || (GET_CODE (PATTERN (insert_after)) == PARALLEL
-	      && GET_CODE (XVECEXP (PATTERN (insert_after), 0, 0)) == SET)))
-    {
-      rtx return_reg;
-      rtx next_insert_after = next_nonnote_insn (insert_after);
-
-      /* The first insn after the call may be a stack pop, skip it.  */
-      if (next_insert_after
-	  && GET_CODE (next_insert_after) == INSN
-	  && GET_CODE (PATTERN (next_insert_after)) == SET
-	  && SET_DEST (PATTERN (next_insert_after)) == stack_pointer_rtx)
-	next_insert_after = next_nonnote_insn (next_insert_after);
-
-      if (next_insert_after
-	  && GET_CODE (next_insert_after) == INSN)
-	{
-	  if (GET_CODE (PATTERN (insert_after)) == SET)
-	    return_reg = SET_DEST (PATTERN (insert_after));
-	  else
-	    return_reg = SET_DEST (XVECEXP (PATTERN (insert_after), 0, 0));
-
-	  /* Now, NEXT_INSERT_AFTER may be an instruction that uses the
-	     return value.  However, it could also be something else,
-	     like a CODE_LABEL, so check that the code is INSN.  */
-	  if (next_insert_after != 0
-	      && GET_RTX_CLASS (GET_CODE (next_insert_after)) == 'i'
-	      && reg_referenced_p (return_reg, PATTERN (next_insert_after)))
-	    insert_after = next_insert_after;
-	}
-    }
-
   start_sequence ();
 
-  emit_move_insn (address_reg, profiler_target_addr);
-  mem_ref = gen_rtx_MEM (mode, address_reg);
-  emit_move_insn (profiler_reg, mem_ref);
+  tmp = force_reg (Pmode, profiler_label);
+  tmp = plus_constant (tmp, LONG_TYPE_SIZE / BITS_PER_UNIT * edgeno);
+  mem_ref = validize_mem (gen_rtx_MEM (mode, tmp));
 
-  add_ref = gen_rtx_PLUS (mode, profiler_reg, GEN_INT (1));
-  emit_move_insn (profiler_reg, add_ref);
+  tmp = expand_binop (mode, add_optab, mem_ref, const1_rtx,
+		      mem_ref, 0, OPTAB_WIDEN);
 
-  /* This is the same rtx as above, but it is not legal to share this rtx.  */
-  mem_ref = gen_rtx_MEM (mode, address_reg);
-  emit_move_insn (mem_ref, profiler_reg);
+  if (tmp != mem_ref)
+    emit_move_insn (copy_rtx (mem_ref), tmp);
 
   sequence = gen_sequence ();
   end_sequence ();
-  emit_insn_after (sequence, insert_after);
+  return sequence;
 }
 
 /* Output code for a constructor that will invoke __bb_init_func, if
@@ -1659,9 +1072,12 @@ output_func_start_profiler ()
   rtx table_address;
   enum machine_mode mode = mode_for_size (LONG_TYPE_SIZE, MODE_INT, 0);
   int save_flag_inline_functions = flag_inline_functions;
+  int save_flag_test_coverage = flag_test_coverage;
+  int save_profile_arc_flag = profile_arc_flag;
+  int save_flag_branch_probabilities = flag_branch_probabilities;
 
   /* It's either already been output, or we don't need it because we're
-     not doing profile-arcs. */
+     not doing profile-edges. */
   if (! need_func_profiler)
     return;
 
@@ -1684,7 +1100,15 @@ output_func_start_profiler ()
   fndecl = build_decl (FUNCTION_DECL, fnname,
 		       build_function_type (void_type_node, NULL_TREE));
   DECL_EXTERNAL (fndecl) = 0;
+
+#if defined(ASM_OUTPUT_CONSTRUCTOR) && defined(ASM_OUTPUT_DESTRUCTOR)
+  /* It can be a static function as long as collect2 does not have
+     to scan the object file to find its ctor/dtor routine.  */
+  TREE_PUBLIC (fndecl) = 0;
+#else
   TREE_PUBLIC (fndecl) = 1;
+#endif
+
   DECL_ASSEMBLER_NAME (fndecl) = fnname;
   DECL_RESULT (fndecl) = build_decl (RESULT_DECL, NULL_TREE, void_type_node);
 
@@ -1715,10 +1139,20 @@ output_func_start_profiler ()
      flag_inline_functions.  */
   flag_inline_functions = 0;
 
+  /* Don't instrument the function that turns on instrumentation.  Which
+     is also handy since we'd get silly warnings about not consuming all
+     of our da_file input.  */
+  flag_test_coverage = 0;
+  profile_arc_flag = 0;
+  flag_branch_probabilities = 0;
+
   rest_of_compilation (fndecl);
 
   /* Reset flag_inline_functions to its original value.  */
   flag_inline_functions = save_flag_inline_functions;
+  flag_test_coverage = save_flag_test_coverage;
+  profile_arc_flag = save_profile_arc_flag;
+  flag_branch_probabilities = save_flag_branch_probabilities;
 
   if (! quiet_flag)
     fflush (asm_out_file);
diff --git a/gcc/rtl.h b/gcc/rtl.h
index de08817..853fd39 100644
--- a/gcc/rtl.h
+++ b/gcc/rtl.h
@@ -1730,10 +1730,8 @@ extern void init_caller_save		PARAMS ((void));
 
 /* In profile.c */
 extern void init_branch_prob		PARAMS ((const char *));
-#ifdef BUFSIZ
-extern void branch_prob			PARAMS ((rtx, FILE *));
-extern void end_branch_prob		PARAMS ((FILE *));
-#endif
+extern void branch_prob			PARAMS ((void));
+extern void end_branch_prob		PARAMS ((void));
 extern void output_func_start_profiler	PARAMS ((void));
 
 /* In reg-stack.c */
diff --git a/gcc/toplev.c b/gcc/toplev.c
index 52f6cb8..e701889 100644
--- a/gcc/toplev.c
+++ b/gcc/toplev.c
@@ -261,8 +261,9 @@ enum dump_file_index
   DFI_gcse,
   DFI_loop,
   DFI_cse2,
+  DFI_cfg,
   DFI_bp,
-  DFI_flow,
+  DFI_life,
   DFI_combine,
   DFI_ce,
   DFI_regmove,
@@ -303,8 +304,9 @@ struct dump_file_info dump_file[DFI_MAX] =
   { "gcse",	'G', 1, 0, 0 },
   { "loop",	'L', 1, 0, 0 },
   { "cse2",	't', 1, 0, 0 },
+  { "cfg",	'f', 1, 0, 0 },
   { "bp",	'b', 1, 0, 0 },
-  { "flow",	'f', 1, 0, 0 },
+  { "life",	'f', 1, 0, 0 },	/* Yes, duplicate enable switch.  */
   { "combine",	'c', 1, 0, 0 },
   { "ce",	'C', 1, 0, 0 },
   { "regmove",	'N', 1, 0, 0 },
@@ -2372,11 +2374,13 @@ compile_file (name)
 
   end_final (dump_base_name);
    
-  if (flag_test_coverage || flag_branch_probabilities)
+  if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
     {
       timevar_push (TV_DUMP);
       open_dump_file (DFI_bp, NULL);
-      end_branch_prob (rtl_dump_file);
+
+      end_branch_prob ();
+
       close_dump_file (DFI_bp, NULL, NULL_RTX);
       timevar_pop (TV_DUMP);
     }
@@ -3101,33 +3105,32 @@ rest_of_compilation (decl)
 
   cse_not_expected = 1;
 
-  if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
-    {
-      timevar_push (TV_BRANCH_PROB);
-      open_dump_file (DFI_bp, decl);
-
-      branch_prob (insns, rtl_dump_file);
-
-      close_dump_file (DFI_bp, print_rtl, insns);
-      timevar_pop (TV_BRANCH_PROB);
-
-      if (ggc_p)
-	ggc_collect ();
-    }
-
   regclass_init ();
 
-  /* Print function header into flow dump now
-     because doing the flow analysis makes some of the dump.  */
-
-  open_dump_file (DFI_flow, decl);
   
   /* Do control and data flow analysis; wrote some of the results to
      the dump file.  */
 
   timevar_push (TV_FLOW);
+  open_dump_file (DFI_cfg, decl);
+
   find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
   cleanup_cfg (insns);
+
+  close_dump_file (DFI_cfg, print_rtl_with_bb, insns);
+ 
+  if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
+    {
+      timevar_push (TV_BRANCH_PROB);
+      open_dump_file (DFI_bp, decl);
+
+      branch_prob ();
+
+      close_dump_file (DFI_bp, print_rtl_with_bb, insns);
+      timevar_pop (TV_BRANCH_PROB);
+    }
+
+  open_dump_file (DFI_life, decl);
   if (optimize)
     {
       struct loops loops;
@@ -3137,8 +3140,7 @@ rest_of_compilation (decl)
       flow_loops_find (&loops);
 
       /* Estimate using heuristics if no profiling info is available.  */
-      if (! flag_branch_probabilities)
-	estimate_probability (&loops);
+      estimate_probability (&loops);
 
       if (rtl_dump_file)
 	flow_loops_dump (&loops, rtl_dump_file, 0);
@@ -3156,7 +3158,7 @@ rest_of_compilation (decl)
 	setjmp_args_warning ();
     }
 
-  close_dump_file (DFI_flow, print_rtl_with_bb, insns);
+  close_dump_file (DFI_life, print_rtl_with_bb, insns);
 
   if (ggc_p)
     ggc_collect ();