This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[tree-ssa] SSA->Normal speedup patch


I noticed a couple of instances where SSA->normal was taking far longer
than it had any right to.

Brad's num.i file (12662) was one such creature, where out of a 100
seconds compilation time (with -fno-tree-pre), 9.5 seconds were being
spent in SSA->normal.

The c++ testcase g++.dg/eh/cleanup1.C was another one, where we had a
312 seconds compile time, and SSA->normal was taking 40 seconds or so.
SSA->normal ought not be taking that long ever.

SO, this patch has 4 changes to address what I found.

1) The elimination graph used by SSA->normal is implemented out of
morgans book. When I implemented it, I snagged a simple conflict graph 
implementation from the RTL SSA implementation. It turns out that to say
this is a sparse graph does not do the term justice. The only things
that ever get entered into this graph are ssa variables along a SINGLE
edge for which the PHI result and the argument on that edge do not
coalesce. 
  In the end, it turns out that in a bootstrap of GCC, there are over
11,000 times we do use the elimination graph, and out of those, only 22
times are there more than 3 entries, and the highwater peak is 7
entries. Time in num.i was being dominated by clearing the sparse
bitmaps, of all things. So I threw away the old sparse bitmap
implementation, and reimplemented it as a simple linear list of edges. 
   That dropped the time in num.i from 9.5 seconds to 3.1 seconds.

2) During building of the SSA conflict graph, everything live at the top
of a block has to conflict with each other. The previous implementation
simply went through the live list, and for every live variable, looked
through its list of "versions" to see if any of them were live and added
a conflict if so. When liveness was sparse, and a variable had 1000
versions, looping through the version list dominated time.
  An alternative would be a nested loop through the live list. The
problem here is that when liveness isn't sparse, you have an expensive
n^2 algorithm.  In some cases this is faster, in some slower
  So now we've got a hybrid. We maintain a quick and dirty list of
versions of a variable that we've seen as we loop through the live list.
A variable is given a conflict with any other version of that variable
in it's list, and then added to the list. This results in a single pass
through the live on entry list, and a simple loop adding conflicts over
jsut the versions already seen. 
  This dropped num.i from 3.1 seconds to 1.6 seconds
  None of this had much effect on cleanup1.C

3) All the live range information in SSA->normal is calculated using
sbitmaps. I converted those routines all to use bitmaps instead. This
brought the time in Cleanup1.C down to 30 seconds, and num.i to 1.47
seconds.

4) Back in July, when I was working on temporary coalescing, the live
range information was needed for all temporaries in order to coalesce
them. I had a brain fart, and although a flag was available for
combining temps (and is off by default), I turned off the optimization
for single-version variables. When there is only a single SSA version of
a variable, there is no need to build live range info, conflict graphs ,
and all that jazz since there is nothing for them to coalesce with. 
   So, re-enabling it when the combine-temps flag isn't on was pretty
easy, and voila, cleanup1.C's SSA->normal time drops to 0.36 seconds.
num.i finishes up around 1.4 seconds.

This bootstraps and causes no new regressions on x86. In addition,
overall time on SSA->normal on a bootstrap stage drops from 4.2 seconds
to 3.2 seconds with these changes.

Andrew

PS. I will be revisiting combine-temps shortly. The plan is to change it
from a general purpose coalece everything possible to only attempt
things which are going to be profitable (ie, things we saw copies of).
We'll then add back in the single_defs which are in the potential
coalesce list. That way we will only get the minimum live range
calculations we need, and we shouldn't see this kind of time explosion.


2003-10-22  Andrew MacLeod  <amacleod@redhat.com>

	* tree-ssa-live.c (new_tree_live_info, (delete_tree_live_info, 
	live_worklist, set_if_valid, add_livein_if_notdef, 
	calculate_live_on_entry, calculate_live_on_exit,
	add_conflicts_if_valid, dump_live_info): Use bitmap instead of sbitmap.
	(build_tree_conflict_graph): Use bitmap, Change mechanism for
	adding conflicts between live-on-entry partitions.
	* tree-ssa-live.h (struct tree_live_info_d): Switch to bitmaps.
	(partition_is_global, live_entry_blocks, live_on_exit, 
	live_merge_and_clear, make_live_on_entry): Switch to bitmaps.
	* tree-ssa.c (struct _elim_graph): Remove bitmaps, use varrays.
	(new_elim_graph, clear_elim_graph, delete_elim_graph): Switch from
	old bitmap implementation.
	(elim_graph_size): New. Number of elements in elimination graph.
	(elim_graph_add_node): New. Add an element to the elim-graph.
	(elim_graph_add_edge): New. Add an edge to the elim-graph.
	(elim_graph_remove_succ_edge): New. Remove an edge for which a node
	has a successor.
	(FOR_EACH_ELIM_GRAPH_SUCC): Find all successor nodes.
	(FOR_EACH_ELIM_GRAPH_PRED): Find all predeccesor nodes.
	(eliminate_name, eliminate_build, elim_forward, 
	elim_unvisited_predecessor, elim_backward, elim_create, eliminate_phi):
	Use new elim-graph routines.
	(rewrite_out_of_ssa): Enable single-definition compaction when not
	combining temporaries.


Index: tree-ssa-live.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/tree-ssa-live.c,v
retrieving revision 1.1.2.22
diff -c -p -r1.1.2.22 tree-ssa-live.c
*** tree-ssa-live.c	18 Oct 2003 03:09:47 -0000	1.1.2.22
--- tree-ssa-live.c	22 Oct 2003 18:03:47 -0000
*************** Boston, MA 02111-1307, USA.  */
*** 41,52 ****
  
  static void live_worklist (tree_live_info_p, varray_type, int);
  static tree_live_info_p new_tree_live_info (var_map);
! static inline void set_if_valid (var_map, sbitmap, tree);
! static inline void add_livein_if_notdef (tree_live_info_p, sbitmap,
  					 tree, basic_block);
  static inline void register_ssa_partition (var_map, tree);
  static inline void add_conflicts_if_valid (tpa_p, conflict_graph,
! 					   var_map, sbitmap, tree);
  static partition_pair_p find_partition_pair (coalesce_list_p, int, int, bool);
  
  /* This is where the mapping from SSA version number to real storage variable
--- 41,52 ----
  
  static void live_worklist (tree_live_info_p, varray_type, int);
  static tree_live_info_p new_tree_live_info (var_map);
! static inline void set_if_valid (var_map, bitmap, tree);
! static inline void add_livein_if_notdef (tree_live_info_p, bitmap,
  					 tree, basic_block);
  static inline void register_ssa_partition (var_map, tree);
  static inline void add_conflicts_if_valid (tpa_p, conflict_graph,
! 					   var_map, bitmap, tree);
  static partition_pair_p find_partition_pair (coalesce_list_p, int, int, bool);
  
  /* This is where the mapping from SSA version number to real storage variable
*************** static tree_live_info_p
*** 420,436 ****
  new_tree_live_info (var_map map)
  {
    tree_live_info_p live;
  
    live = (tree_live_info_p) xmalloc (sizeof (struct tree_live_info_d));
    live->map = map;
    live->num_blocks = n_basic_blocks;
  
!   live->global = sbitmap_alloc (num_var_partitions (map));
!   sbitmap_zero (live->global);
  
!   live->livein = sbitmap_vector_alloc (num_var_partitions (map), 
! 				       live->num_blocks);
!   sbitmap_vector_zero (live->livein, num_var_partitions (map));
  
    /* liveout is deferred until it is actually requested.  */
    live->liveout = NULL;
--- 420,436 ----
  new_tree_live_info (var_map map)
  {
    tree_live_info_p live;
+   int x;
  
    live = (tree_live_info_p) xmalloc (sizeof (struct tree_live_info_d));
    live->map = map;
    live->num_blocks = n_basic_blocks;
  
!   live->global = BITMAP_XMALLOC ();
  
!   live->livein = (bitmap *)xmalloc (num_var_partitions (map) * sizeof (bitmap));
!   for (x = 0; x < num_var_partitions (map); x++)
!     live->livein[x] = BITMAP_XMALLOC ();
  
    /* liveout is deferred until it is actually requested.  */
    live->liveout = NULL;
*************** new_tree_live_info (var_map map)
*** 442,453 ****
  void 
  delete_tree_live_info (tree_live_info_p live)
  {
    if (live->liveout)
!     sbitmap_vector_free (live->liveout);
    if (live->livein)
!     sbitmap_vector_free (live->livein);
    if (live->global)
!     sbitmap_vector_free (live->global);
    
    free (live);
  }
--- 442,462 ----
  void 
  delete_tree_live_info (tree_live_info_p live)
  {
+   int x;
    if (live->liveout)
!     {
!       for (x = live->num_blocks - 1; x >= 0; x--)
!         BITMAP_XFREE (live->liveout[x]);
!       free (live->liveout);
!     }
    if (live->livein)
!     {
!       for (x = num_var_partitions (live->map) - 1; x >= 0; x--)
!         BITMAP_XFREE (live->livein[x]);
!       free (live->livein);
!     }
    if (live->global)
!     BITMAP_XFREE (live->global);
    
    free (live);
  }
*************** live_worklist (tree_live_info_p live, va
*** 468,474 ****
    if (SSA_NAME_DEF_STMT (var))
      def_bb = bb_for_stmt (SSA_NAME_DEF_STMT (var));
  
!   EXECUTE_IF_SET_IN_SBITMAP (live->livein[i], 0, b,
      {
        VARRAY_PUSH_INT (stack, b);
      });
--- 477,483 ----
    if (SSA_NAME_DEF_STMT (var))
      def_bb = bb_for_stmt (SSA_NAME_DEF_STMT (var));
  
!   EXECUTE_IF_SET_IN_BITMAP (live->livein[i], 0, b,
      {
        VARRAY_PUSH_INT (stack, b);
      });
*************** live_worklist (tree_live_info_p live, va
*** 484,492 ****
  	    /* Its not live on entry to the block its defined in.  */
  	    if (e->src == def_bb)
  	      continue;
! 	    if (!TEST_BIT (live->livein[i], e->src->index))
  	      {
! 	        SET_BIT (live->livein[i], e->src->index);
  		VARRAY_PUSH_INT (stack, e->src->index);
  	      }
  	  }
--- 493,501 ----
  	    /* Its not live on entry to the block its defined in.  */
  	    if (e->src == def_bb)
  	      continue;
! 	    if (!bitmap_bit_p (live->livein[i], e->src->index))
  	      {
! 	        bitmap_set_bit (live->livein[i], e->src->index);
  		VARRAY_PUSH_INT (stack, e->src->index);
  	      }
  	  }
*************** live_worklist (tree_live_info_p live, va
*** 497,523 ****
  /* If a variable is in a partition, set the bit for that partition.  */
  
  static inline void
! set_if_valid (var_map map, sbitmap vec, tree var)
  {
    int p = var_to_partition (map, var);
    if (p != NO_PARTITION)
!     SET_BIT (vec, p);
  }
  
  /* If a variable is in a partition and it isn't defined, set the livein and 
     global bit for it.  */
  
  static inline void
! add_livein_if_notdef (tree_live_info_p live, sbitmap def_vec,
  		      tree var, basic_block bb)
  {
    int p = var_to_partition (live->map, var);
    if (p == NO_PARTITION || bb == ENTRY_BLOCK_PTR)
      return;
!   if (!TEST_BIT (def_vec, p))
      {
!       SET_BIT (live->livein[p], bb->index);
!       SET_BIT (live->global, p);
      }
  }
  
--- 506,532 ----
  /* If a variable is in a partition, set the bit for that partition.  */
  
  static inline void
! set_if_valid (var_map map, bitmap vec, tree var)
  {
    int p = var_to_partition (map, var);
    if (p != NO_PARTITION)
!     bitmap_set_bit (vec, p);
  }
  
  /* If a variable is in a partition and it isn't defined, set the livein and 
     global bit for it.  */
  
  static inline void
! add_livein_if_notdef (tree_live_info_p live, bitmap def_vec,
  		      tree var, basic_block bb)
  {
    int p = var_to_partition (live->map, var);
    if (p == NO_PARTITION || bb == ENTRY_BLOCK_PTR)
      return;
!   if (!bitmap_bit_p (def_vec, p))
      {
!       bitmap_set_bit (live->livein[p], bb->index);
!       bitmap_set_bit (live->global, p);
      }
  }
  
*************** calculate_live_on_entry (var_map map)
*** 530,536 ****
    tree_live_info_p live;
    int num, i;
    basic_block bb;
!   sbitmap saw_def;
    tree phi, var, stmt;
    tree *vec;
    edge e;
--- 539,545 ----
    tree_live_info_p live;
    int num, i;
    basic_block bb;
!   bitmap saw_def;
    tree phi, var, stmt;
    tree *vec;
    edge e;
*************** calculate_live_on_entry (var_map map)
*** 539,551 ****
    varray_type ops;
    stmt_ann_t ann;
  
!   saw_def = sbitmap_alloc (num_var_partitions (map));
  
    live = new_tree_live_info (map);
  
    FOR_EACH_BB (bb)
      {
!       sbitmap_zero (saw_def);
  
        for (phi = phi_nodes (bb); phi; phi = TREE_CHAIN (phi))
  	{
--- 548,560 ----
    varray_type ops;
    stmt_ann_t ann;
  
!   saw_def = BITMAP_XMALLOC ();
  
    live = new_tree_live_info (map);
  
    FOR_EACH_BB (bb)
      {
!       bitmap_clear (saw_def);
  
        for (phi = phi_nodes (bb); phi; phi = TREE_CHAIN (phi))
  	{
*************** calculate_live_on_entry (var_map map)
*** 627,633 ****
      }
  
    VARRAY_INT_INIT (stack, n_basic_blocks, "stack");
!   EXECUTE_IF_SET_IN_SBITMAP (live->global, 0, i,
      {
        live_worklist (live, stack, i);
      });
--- 636,642 ----
      }
  
    VARRAY_INT_INIT (stack, n_basic_blocks, "stack");
!   EXECUTE_IF_SET_IN_BITMAP (live->global, 0, i,
      {
        live_worklist (live, stack, i);
      });
*************** calculate_live_on_entry (var_map map)
*** 653,659 ****
  	  tmp = bb_for_stmt (stmt);
  	  d = default_def (SSA_NAME_VAR (var));
  
! 	  if (TEST_BIT (live_entry_blocks (live, i), entry_block))
  	    {
  	      if (!IS_EMPTY_STMT (stmt))
  		{
--- 662,668 ----
  	  tmp = bb_for_stmt (stmt);
  	  d = default_def (SSA_NAME_VAR (var));
  
! 	  if (bitmap_bit_p (live_entry_blocks (live, i), entry_block))
  	    {
  	      if (!IS_EMPTY_STMT (stmt))
  		{
*************** void
*** 727,742 ****
  calculate_live_on_exit (tree_live_info_p liveinfo)
  {
    unsigned b;
!   int i;
!   sbitmap *on_exit;
    basic_block bb;
    edge e;
    tree t, phi;
!   sbitmap on_entry;
    var_map map = liveinfo->map;
  
!   on_exit = sbitmap_vector_alloc (n_basic_blocks, num_var_partitions (map));
!   sbitmap_vector_zero (on_exit, n_basic_blocks);
  
    /* Set all the live-on-exit bits for uses in PHIs.  */
    FOR_EACH_BB (bb)
--- 736,752 ----
  calculate_live_on_exit (tree_live_info_p liveinfo)
  {
    unsigned b;
!   int i, x;
!   bitmap *on_exit;
    basic_block bb;
    edge e;
    tree t, phi;
!   bitmap on_entry;
    var_map map = liveinfo->map;
  
!   on_exit = (bitmap *)xmalloc (n_basic_blocks * sizeof (bitmap));
!   for (x = 0; x < n_basic_blocks; x++)
!     on_exit[x] = BITMAP_XMALLOC ();
  
    /* Set all the live-on-exit bits for uses in PHIs.  */
    FOR_EACH_BB (bb)
*************** calculate_live_on_exit (tree_live_info_p
*** 756,766 ****
    for (i = 0; i < num_var_partitions (map); i++)
      {
        on_entry = live_entry_blocks (liveinfo, i);
!       EXECUTE_IF_SET_IN_SBITMAP (on_entry, 0, b,
          {
  	  for (e = BASIC_BLOCK(b)->pred; e; e = e->pred_next)
  	    if (e->src != ENTRY_BLOCK_PTR)
! 	      SET_BIT (on_exit[e->src->index], i);
  	});
      }
  
--- 766,776 ----
    for (i = 0; i < num_var_partitions (map); i++)
      {
        on_entry = live_entry_blocks (liveinfo, i);
!       EXECUTE_IF_SET_IN_BITMAP (on_entry, 0, b,
          {
  	  for (e = BASIC_BLOCK(b)->pred; e; e = e->pred_next)
  	    if (e->src != ENTRY_BLOCK_PTR)
! 	      bitmap_set_bit (on_exit[e->src->index], i);
  	});
      }
  
*************** pop_best_coalesce (coalesce_list_p cl, i
*** 1255,1267 ****
  
  static inline void 
  add_conflicts_if_valid (tpa_p tpa, conflict_graph graph,
! 			var_map map, sbitmap vec, tree var)
  { 
    int p, y, first;
    p = var_to_partition (map, var);
    if (p != NO_PARTITION)
      { 
!       RESET_BIT (vec, p);
        first = tpa_find_tree (tpa, p);
        /* If find returns nothing, this object isn't interesting.  */
        if (first == TPA_NONE)
--- 1265,1277 ----
  
  static inline void 
  add_conflicts_if_valid (tpa_p tpa, conflict_graph graph,
! 			var_map map, bitmap vec, tree var)
  { 
    int p, y, first;
    p = var_to_partition (map, var);
    if (p != NO_PARTITION)
      { 
!       bitmap_clear_bit (vec, p);
        first = tpa_find_tree (tpa, p);
        /* If find returns nothing, this object isn't interesting.  */
        if (first == TPA_NONE)
*************** add_conflicts_if_valid (tpa_p tpa, confl
*** 1271,1277 ****
  	   y != TPA_NONE;
  	   y = tpa_next_partition (tpa, y))
  	{
! 	  if (TEST_BIT (vec, y))
  	    conflict_graph_add (graph, p, y);
  	}
      }
--- 1281,1287 ----
  	   y != TPA_NONE;
  	   y = tpa_next_partition (tpa, y))
  	{
! 	  if (bitmap_bit_p (vec, y))
  	    conflict_graph_add (graph, p, y);
  	}
      }
*************** build_tree_conflict_graph (tree_live_inf
*** 1288,1299 ****
  {
    conflict_graph graph;
    var_map map;
!   sbitmap live;
    int num, x, y, i;
    basic_block bb;
!   varray_type stmt_stack, ops;
    stmt_ann_t ann;
    tree stmt, *var_p;
  
    map = live_var_map (liveinfo);
    graph = conflict_graph_new (num_var_partitions (map));
--- 1298,1310 ----
  {
    conflict_graph graph;
    var_map map;
!   bitmap live;
    int num, x, y, i;
    basic_block bb;
!   varray_type stmt_stack, ops, partition_link, tpa_to_clear, tpa_nodes;
    stmt_ann_t ann;
    tree stmt, *var_p;
+   unsigned l;
  
    map = live_var_map (liveinfo);
    graph = conflict_graph_new (num_var_partitions (map));
*************** build_tree_conflict_graph (tree_live_inf
*** 1301,1312 ****
    if (tpa_num_trees (tpa) == 0)
      return graph;
  
!   live = sbitmap_alloc (num_var_partitions (map));
  
    FOR_EACH_BB (bb)
      {
        /* Start with live on exit temporaries.  */
!       sbitmap_copy (live, live_on_exit (liveinfo, bb));
  
        FOR_EACH_STMT_IN_REVERSE (stmt_stack, bb, stmt)
          {
--- 1312,1327 ----
    if (tpa_num_trees (tpa) == 0)
      return graph;
  
!   live = BITMAP_XMALLOC ();
! 
!   VARRAY_INT_INIT (partition_link, num_var_partitions (map) + 1, "part_link");
!   VARRAY_INT_INIT (tpa_nodes, tpa_num_trees (tpa), "tpa nodes");
!   VARRAY_INT_INIT (tpa_to_clear, 50, "tpa to clear");
  
    FOR_EACH_BB (bb)
      {
        /* Start with live on exit temporaries.  */
!       bitmap_copy (live, live_on_exit (liveinfo, bb));
  
        FOR_EACH_STMT_IN_REVERSE (stmt_stack, bb, stmt)
          {
*************** build_tree_conflict_graph (tree_live_inf
*** 1345,1358 ****
  	      if (p1 != NO_PARTITION && p2 != NO_PARTITION)
  		{
  		  important_copy_rhs_partition = rhs;
! 		  bit = TEST_BIT (live, p2);
  		  /* If the RHS is live, make it not live while we add
  		     the conflicts, then make it live again.  */
  		  if (bit)
! 		    RESET_BIT (live, p2);
  		  add_conflicts_if_valid (tpa, graph, map, live, lhs);
  		  if (bit)
! 		    SET_BIT (live, p2);
  		  if (cl)
  		    add_coalesce (cl, p1, p2, 1);
  		  set_if_valid (map, live, important_copy_rhs_partition);
--- 1360,1373 ----
  	      if (p1 != NO_PARTITION && p2 != NO_PARTITION)
  		{
  		  important_copy_rhs_partition = rhs;
! 		  bit = bitmap_bit_p (live, p2);
  		  /* If the RHS is live, make it not live while we add
  		     the conflicts, then make it live again.  */
  		  if (bit)
! 		    bitmap_clear_bit (live, p2);
  		  add_conflicts_if_valid (tpa, graph, map, live, lhs);
  		  if (bit)
! 		    bitmap_set_bit (live, p2);
  		  if (cl)
  		    add_coalesce (cl, p1, p2, 1);
  		  set_if_valid (map, live, important_copy_rhs_partition);
*************** build_tree_conflict_graph (tree_live_inf
*** 1379,1403 ****
  	    }
  	}
  
!       /* Anything which is still live at this point interferes.  */
  
!       EXECUTE_IF_SET_IN_SBITMAP (live, 0, x,
          {
  	  i = tpa_find_tree (tpa, x);
! 	  if (i == TPA_NONE)
! 	    continue;
! 	  for (y = tpa_first_partition (tpa, i);
! 	       y != TPA_NONE;
! 	       y = tpa_next_partition (tpa, y))
  	    {
! 	      if (x != y && TEST_BIT (live, y))
! 		conflict_graph_add (graph, x, y);
  	    }
- 
  	});
      }
  
!   sbitmap_free (live);
    return graph;
  }
  
--- 1394,1438 ----
  	    }
  	}
  
!       /* Anything which is still live at this point interferes.  
! 	 In order to implement this efficiently, only conflicts between
! 	 partitions which have the same TPA root need be added.
! 	 TPA roots which have been seen are tracked in 'tpa_nodes'. A non-zero
! 	 entry points to an index into 'partition_link', which then indexes 
! 	 into itself forming a linked list of partitions sharing a tpa root 
! 	 which have been seen as live up to this point.  Since partitions start
! 	 at index zero, all entries in partition_link are (partition + 1).
! 
! 	 Conflicts are added between the current partition and any already seen.
! 	 tpa_clear contains all the tpa_roots processed, and these are the only
! 	 entries which need to be zero'd out for a clean restart.  */
  
!       EXECUTE_IF_SET_IN_BITMAP (live, 0, x,
          {
  	  i = tpa_find_tree (tpa, x);
! 	  if (i != TPA_NONE)
  	    {
! 	      int start = VARRAY_INT (tpa_nodes, i);
! 	      /* If start is 0, a new root reference list is being started.
! 		 Register it to be cleared.  */
! 	      if (!start)
! 	        VARRAY_PUSH_INT (tpa_to_clear, i);
! 
! 	      /* Add interferences to other tpa members seen.  */
! 	      for (y = start; y != 0; y = VARRAY_INT (partition_link, y))
! 		conflict_graph_add (graph, x, y - 1);
! 	      VARRAY_INT (tpa_nodes, i) = x + 1;
! 	      VARRAY_INT (partition_link, x + 1) = start;
  	    }
  	});
+ 
+ 	/* Now clear the used tpa root references.  */
+ 	for (l = 0; l < VARRAY_ACTIVE_SIZE (tpa_to_clear); l++)
+ 	  VARRAY_INT (tpa_nodes, VARRAY_INT (tpa_to_clear, l)) = 0;
+ 	VARRAY_POP_ALL (tpa_to_clear);
      }
  
!   BITMAP_XFREE (live);
    return graph;
  }
  
*************** dump_live_info (FILE *f, tree_live_info_
*** 1625,1631 ****
  	  fprintf (f, "\nLive on entry to BB%d : ", bb->index);
  	  for (i = 0; i < num_var_partitions (map); i++)
  	    {
! 	      if (TEST_BIT (live_entry_blocks (live, i), bb->index))
  	        {
  		  print_generic_expr (f, partition_to_var (map, i), TDF_SLIM);
  		  fprintf (f, "  ");
--- 1660,1666 ----
  	  fprintf (f, "\nLive on entry to BB%d : ", bb->index);
  	  for (i = 0; i < num_var_partitions (map); i++)
  	    {
! 	      if (bitmap_bit_p (live_entry_blocks (live, i), bb->index))
  	        {
  		  print_generic_expr (f, partition_to_var (map, i), TDF_SLIM);
  		  fprintf (f, "  ");
*************** dump_live_info (FILE *f, tree_live_info_
*** 1640,1646 ****
        FOR_EACH_BB (bb)
  	{
  	  fprintf (f, "\nLive on exit from BB%d : ", bb->index);
! 	  EXECUTE_IF_SET_IN_SBITMAP (live->liveout[bb->index], 0, i,
  	    {
  	      print_generic_expr (f, partition_to_var (map, i), TDF_SLIM);
  	      fprintf (f, "  ");
--- 1675,1681 ----
        FOR_EACH_BB (bb)
  	{
  	  fprintf (f, "\nLive on exit from BB%d : ", bb->index);
! 	  EXECUTE_IF_SET_IN_BITMAP (live->liveout[bb->index], 0, i,
  	    {
  	      print_generic_expr (f, partition_to_var (map, i), TDF_SLIM);
  	      fprintf (f, "  ");
Index: tree-ssa-live.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/tree-ssa-live.h,v
retrieving revision 1.1.2.8
diff -c -p -r1.1.2.8 tree-ssa-live.h
*** tree-ssa-live.h	18 Oct 2003 03:09:47 -0000	1.1.2.8
--- tree-ssa-live.h	22 Oct 2003 18:03:47 -0000
*************** typedef struct tree_live_info_d
*** 163,178 ****
    var_map map;
  
    /* Bitmap indicating which partitions are global.  */
!   sbitmap global;
  
    /* Bitmap of live on entry blocks for partition elements.  */
!   sbitmap *livein;
  
    /* Number of basic blocks when live on exit calculated.  */
    int num_blocks;
  
    /* Bitmap of what variables are live on exit for a basic blocks.  */
!   sbitmap *liveout;
  } *tree_live_info_p;
  
  
--- 163,178 ----
    var_map map;
  
    /* Bitmap indicating which partitions are global.  */
!   bitmap global;
  
    /* Bitmap of live on entry blocks for partition elements.  */
!   bitmap *livein;
  
    /* Number of basic blocks when live on exit calculated.  */
    int num_blocks;
  
    /* Bitmap of what variables are live on exit for a basic blocks.  */
!   bitmap *liveout;
  } *tree_live_info_p;
  
  
*************** extern void delete_tree_live_info (tree_
*** 186,193 ****
  extern void dump_live_info (FILE *, tree_live_info_p, int);
  
  static inline int partition_is_global (tree_live_info_p, int);
! static inline sbitmap live_entry_blocks (tree_live_info_p, int);
! static inline sbitmap live_on_exit (tree_live_info_p, basic_block);
  static inline var_map live_var_map (tree_live_info_p);
  static inline void live_merge_and_clear (tree_live_info_p, int, int);
  static inline void make_live_on_entry (tree_live_info_p, basic_block, int);
--- 186,193 ----
  extern void dump_live_info (FILE *, tree_live_info_p, int);
  
  static inline int partition_is_global (tree_live_info_p, int);
! static inline bitmap live_entry_blocks (tree_live_info_p, int);
! static inline bitmap live_on_exit (tree_live_info_p, basic_block);
  static inline var_map live_var_map (tree_live_info_p);
  static inline void live_merge_and_clear (tree_live_info_p, int, int);
  static inline void make_live_on_entry (tree_live_info_p, basic_block, int);
*************** partition_is_global (tree_live_info_p li
*** 198,207 ****
    if (!live->global)
      abort ();
  
!   return TEST_BIT (live->global, p);
  }
  
! static inline sbitmap
  live_entry_blocks (tree_live_info_p live, int p)
  {
    if (!live->livein)
--- 198,207 ----
    if (!live->global)
      abort ();
  
!   return bitmap_bit_p (live->global, p);
  }
  
! static inline bitmap
  live_entry_blocks (tree_live_info_p live, int p)
  {
    if (!live->livein)
*************** live_entry_blocks (tree_live_info_p live
*** 210,216 ****
    return live->livein[p];
  }
  
! static inline sbitmap
  live_on_exit (tree_live_info_p live, basic_block bb)
  {
    if (!live->liveout)
--- 210,216 ----
    return live->livein[p];
  }
  
! static inline bitmap
  live_on_exit (tree_live_info_p live, basic_block bb)
  {
    if (!live->liveout)
*************** live_var_map (tree_live_info_p live)
*** 233,247 ****
  static inline void 
  live_merge_and_clear (tree_live_info_p live, int p1, int p2)
  {
!   sbitmap_a_or_b (live->livein[p1], live->livein[p1], live->livein[p2]);
!   sbitmap_zero (live->livein[p2]);
  }
  
  static inline void 
  make_live_on_entry (tree_live_info_p live, basic_block bb , int p)
  {
!   SET_BIT (live->livein[p], bb->index);
!   SET_BIT (live->global, p);
  }
  
  /* A tree_partition_associator object is a base structure which allows
--- 233,247 ----
  static inline void 
  live_merge_and_clear (tree_live_info_p live, int p1, int p2)
  {
!   bitmap_a_or_b (live->livein[p1], live->livein[p1], live->livein[p2]);
!   bitmap_zero (live->livein[p2]);
  }
  
  static inline void 
  make_live_on_entry (tree_live_info_p live, basic_block bb , int p)
  {
!   bitmap_set_bit (live->livein[p], bb->index);
!   bitmap_set_bit (live->global, p);
  }
  
  /* A tree_partition_associator object is a base structure which allows
Index: tree-ssa.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/tree-ssa.c,v
retrieving revision 1.1.4.138
diff -c -p -r1.1.4.138 tree-ssa.c
*** tree-ssa.c	18 Oct 2003 03:09:47 -0000	1.1.4.138
--- tree-ssa.c	22 Oct 2003 18:03:48 -0000
*************** struct GTY(()) var_value_d
*** 99,123 ****
    tree value;
  };
  
! /* Used to hold all the components requires to do SSA PHI elimination.  */
! 
  typedef struct _elim_graph
  {
    /* Size of the elimination vectors.  */
    int size;
!   /* Number of nodes entered into the elimination graph.  */
!   int num_nodes;
!   /* The actual nodes in the elimination graph.  */
!   tree *nodes;
!   /* The predecessor and successor list.  */
!   bitmap *pred;
!   bitmap *succ;
  
    /* Visited vector.  */
    sbitmap visited;
    /* Stack for visited nodes.  */
!   int *stack;
!   int top_of_stack;
    
    /* The variable partition map.  */
    var_map map;
--- 99,140 ----
    tree value;
  };
  
! /* Used to hold all the components requires to do SSA PHI elimination.
!    The implementation of the node list and pred/succ list has been changed
!    to a simple linear list of nodes and edges represented as pairs of nodes.
! 
!    The predecessor and successor list.  Nodes are enterd in pairs, where
!    [0] ->PRED, [1]->SUCC.  All the even indexes in the array represent 
!    predecessors, all the odd elements are successors. 
!    
!    Rationale:
!    When implemented as bitmaps, very large programs SSA->Normal times were 
!    being dominated by clearing the interference graph.
! 
!    Typically this list of edges is extremely small since it only includes 
!    PHI results and uses from a single edge which have not coalesced with 
!    each other. This means no virtual PHI nodes are included, and empirical
!    evidence suggests that the number of edges rarely exceed 3, and in a 
!    bootstrap of GCC, the maximum size encountered was 7. THis also limits 
!    the number of possible nodes that are involved to rarely more than 6, 
!    and in the bootstrap of gcc, the maximum number of nodes encountered
!    was 12.  */
!  
  typedef struct _elim_graph
  {
    /* Size of the elimination vectors.  */
    int size;
! 
!   /* List of nodes in the elimination graph.  */
!   varray_type nodes;
!   /*  The predecessor and successor edge list. */
!   varray_type edge_list;
  
    /* Visited vector.  */
    sbitmap visited;
+ 
    /* Stack for visited nodes.  */
!   varray_type stack;
    
    /* The variable partition map.  */
    var_map map;
*************** static void htab_statistics (FILE *, hta
*** 170,179 ****
  static tree create_temp (tree);
  static void insert_copy_on_edge (edge, tree, tree);
  static elim_graph new_elim_graph (int);
! static void delete_elim_graph (elim_graph);
! static void clear_elim_graph (elim_graph);
! static void eliminate_name (elim_graph, tree);
! static int eliminate_build (elim_graph, basic_block, int);
  static void elim_forward (elim_graph, int);
  static int elim_unvisited_predecessor (elim_graph, int);
  static void elim_backward (elim_graph, int);
--- 187,201 ----
  static tree create_temp (tree);
  static void insert_copy_on_edge (edge, tree, tree);
  static elim_graph new_elim_graph (int);
! static inline void delete_elim_graph (elim_graph);
! static inline void clear_elim_graph (elim_graph);
! static inline int elim_graph_size (elim_graph);
! static inline void elim_graph_add_node (elim_graph, tree);
! static inline void elim_graph_add_edge (elim_graph, int, int);
! static inline int elim_graph_remove_succ_edge (elim_graph, int);
! 
! static inline void eliminate_name (elim_graph, tree);
! static void eliminate_build (elim_graph, basic_block, int);
  static void elim_forward (elim_graph, int);
  static int elim_unvisited_predecessor (elim_graph, int);
  static void elim_backward (elim_graph, int);
*************** insert_copy_on_edge (edge e, tree dest, 
*** 921,1018 ****
  static elim_graph
  new_elim_graph (int size)
  {
-   int x;
    elim_graph g = (elim_graph) xmalloc (sizeof (struct _elim_graph));
  
!   g->size = size;
!   g->nodes = (tree *) xmalloc (sizeof (tree) * size);
! 
!   g->pred = (bitmap *) xmalloc (sizeof (bitmap) * size);
!   g->succ= (bitmap *) xmalloc (sizeof (bitmap) * size);
!   for (x = 0; x < size; x++)
!     {
!       g->pred[x] = BITMAP_XMALLOC ();
!       g->succ[x] = BITMAP_XMALLOC ();
!     }
    g->visited = sbitmap_alloc (size);
-   g->stack = (int *) xmalloc (sizeof (int) * size);
  
-   VARRAY_TREE_INIT (g->const_copies, 20, "Constant Copies");
-   
    return g;
  }
  
! static void
  clear_elim_graph (elim_graph g)
  {
!   int x;
!   int size = g->size;
! 
!   g->num_nodes = 0;
!   memset (g->nodes, 0, sizeof (tree) * size);
!   for (x = 0; x < size; x++)
!     {
!       bitmap_clear (g->pred[x]);
!       bitmap_clear (g->succ[x]);
!     }
  }
  
  /* Delete an elimination graph.  */
! static void
  delete_elim_graph (elim_graph g)
  {
-   int x;
-   free (g->stack);
    sbitmap_free (g->visited);
  
-   for (x = g->size - 1; x >= 0 ; x--)
-     {
-       BITMAP_XFREE (g->succ[x]);
-       BITMAP_XFREE (g->pred[x]);
-     }
-   free (g->succ);
-   free (g->pred);
  
!   free (g->nodes);
!   free (g);
  }
  
  /* The following procedures implement the out of SSA algorithm detailed in 
     the Morgan Book pages 176-186.  */
  
  
  /* Add T to the elimination graph.  */
  
! static void
  eliminate_name (elim_graph g, tree T)
  {
!   int version = var_to_partition (g->map, T);
! 
!   /* If this is the first time a node is added, clear the graph.
!      Delaying it until here prevents clearing all the vectors
!      until it is known for sure that they are going to be used.  */
! 
!   if (g->num_nodes == 0)
!     clear_elim_graph (g);
! 
!   if (g->nodes[version] == NULL)
!     {
!       g->nodes[version] = T;
!       g->num_nodes++;
!     }
  }
  
  /* Build the auxiliary graph.  */
  
! static int
  eliminate_build (elim_graph g, basic_block B, int i)
  {
    tree phi;
    tree T0, Ti;
    int p0, pi;
-   int edges = 0;
  
!   g->num_nodes = 0;
    
    for (phi = phi_nodes (B); phi; phi = TREE_CHAIN (phi))
      {
--- 943,1078 ----
  static elim_graph
  new_elim_graph (int size)
  {
    elim_graph g = (elim_graph) xmalloc (sizeof (struct _elim_graph));
  
!   VARRAY_TREE_INIT (g->nodes, 30, "Elimination Node List");
!   VARRAY_TREE_INIT (g->const_copies, 20, "Elimination Constant Copies");
!   VARRAY_INT_INIT (g->edge_list, 20, "Elimination Edge List");
!   VARRAY_INT_INIT (g->stack, 30, " Elimination Stack");
!   
    g->visited = sbitmap_alloc (size);
  
    return g;
  }
  
! 
! /* Empty the elimination graph.  */
! static inline void
  clear_elim_graph (elim_graph g)
  {
!   VARRAY_POP_ALL (g->nodes);
!   VARRAY_POP_ALL (g->edge_list);
  }
  
+ 
  /* Delete an elimination graph.  */
! static inline void
  delete_elim_graph (elim_graph g)
  {
    sbitmap_free (g->visited);
+   free (g);
+ }
  
  
! /* Return the number of nodes in the graph.  */
! static inline int
! elim_graph_size (elim_graph g)
! {
!   return VARRAY_ACTIVE_SIZE (g->nodes);
  }
  
+ 
+ /* Add a node to the graph, if it doesn't exist already.  */
+ static inline void 
+ elim_graph_add_node (elim_graph g, tree node)
+ {
+   int x;
+   for (x = 0; x < elim_graph_size (g); x++)
+     if (VARRAY_TREE (g->nodes, x) == node)
+       return;
+   VARRAY_PUSH_TREE (g->nodes, node);
+ }
+ 
+ 
+ /* Add an edge to the graph.  */
+ static inline void
+ elim_graph_add_edge (elim_graph g, int pred, int succ)
+ {
+   VARRAY_PUSH_INT (g->edge_list, pred);
+   VARRAY_PUSH_INT (g->edge_list, succ);
+ }
+ 
+ 
+ /* Remove an edge from the graph for which node is the predecessor, and
+    return the successor node.  -1 is returned if there is no such edge.  */
+ static inline int
+ elim_graph_remove_succ_edge (elim_graph g, int node)
+ {
+   int y;
+   unsigned x;
+   for (x = 0; x < VARRAY_ACTIVE_SIZE (g->edge_list); x += 2)
+     if (VARRAY_INT (g->edge_list, x) == node)
+       {
+         VARRAY_INT (g->edge_list, x) = -1;
+ 	y = VARRAY_INT (g->edge_list, x + 1);
+ 	VARRAY_INT (g->edge_list, x + 1) = -1;
+ 	return y;
+       }
+   return -1;
+ }
+ 
+ /* Find all the nodes which are successors to NODE in the edge list.  */
+ #define FOR_EACH_ELIM_GRAPH_SUCC(GRAPH, NODE, VAR, CODE)		\
+ do {									\
+   unsigned x_;								\
+   int y_;								\
+   for (x_ = 0; x_ < VARRAY_ACTIVE_SIZE ((GRAPH)->edge_list); x_ += 2)	\
+     {									\
+       y_ = VARRAY_INT ((GRAPH)->edge_list, x_);				\
+       if (y_ != (NODE))							\
+         continue;							\
+       (VAR) = VARRAY_INT ((GRAPH)->edge_list, x_ + 1);			\
+       CODE;								\
+     }									\
+ } while (0)
+ 
+ /* Find all the nodes which are predecessors of NODE in the edge list.  */
+ #define FOR_EACH_ELIM_GRAPH_PRED(GRAPH, NODE, VAR, CODE)		\
+ do {									\
+   unsigned x_;								\
+   int y_;								\
+   for (x_ = 0; x_ < VARRAY_ACTIVE_SIZE ((GRAPH)->edge_list); x_ += 2)	\
+     {									\
+       y_ = VARRAY_INT ((GRAPH)->edge_list, x_ + 1);			\
+       if (y_ != (NODE))							\
+         continue;							\
+       (VAR) = VARRAY_INT ((GRAPH)->edge_list, x_);			\
+       CODE;								\
+     }									\
+ } while (0)
+ 
  /* The following procedures implement the out of SSA algorithm detailed in 
     the Morgan Book pages 176-186.  */
  
  
  /* Add T to the elimination graph.  */
  
! static inline void
  eliminate_name (elim_graph g, tree T)
  {
!   elim_graph_add_node (g, T);
  }
  
  /* Build the auxiliary graph.  */
  
! static void
  eliminate_build (elim_graph g, basic_block B, int i)
  {
    tree phi;
    tree T0, Ti;
    int p0, pi;
  
!   clear_elim_graph (g);
    
    for (phi = phi_nodes (B); phi; phi = TREE_CHAIN (phi))
      {
*************** eliminate_build (elim_graph g, basic_blo
*** 1045,1057 ****
  	      eliminate_name (g, Ti);
  	      p0 = var_to_partition (g->map, T0);
  	      pi = var_to_partition (g->map, Ti);
! 	      bitmap_set_bit (g->pred[pi], p0);
! 	      bitmap_set_bit (g->succ[p0], pi);
! 	      edges++;
  	    }
  	}
      }
-   return edges;
  }
  
  /* Push successors onto the stack depth first.  */
--- 1105,1114 ----
  	      eliminate_name (g, Ti);
  	      p0 = var_to_partition (g->map, T0);
  	      pi = var_to_partition (g->map, Ti);
! 	      elim_graph_add_edge (g, p0, pi);
  	    }
  	}
      }
  }
  
  /* Push successors onto the stack depth first.  */
*************** elim_forward (elim_graph g, int T)
*** 1061,1073 ****
  {
    int S;
    SET_BIT (g->visited, T);
!   EXECUTE_IF_SET_IN_BITMAP (g->succ[T], 0, S,
      {
        if (!TEST_BIT (g->visited, S))
          elim_forward (g, S);
      });
!   g->stack[g->top_of_stack] = T;
!   g->top_of_stack++;
  }
  
  
--- 1118,1129 ----
  {
    int S;
    SET_BIT (g->visited, T);
!   FOR_EACH_ELIM_GRAPH_SUCC (g, T, S,
      {
        if (!TEST_BIT (g->visited, S))
          elim_forward (g, S);
      });
!   VARRAY_PUSH_INT (g->stack, T);
  }
  
  
*************** static int
*** 1077,1083 ****
  elim_unvisited_predecessor (elim_graph g, int T)
  {
    int P;
!   EXECUTE_IF_SET_IN_BITMAP (g->pred[T], 0, P,
      {
        if (!TEST_BIT (g->visited, P))
          return 1;
--- 1133,1139 ----
  elim_unvisited_predecessor (elim_graph g, int T)
  {
    int P;
!   FOR_EACH_ELIM_GRAPH_PRED (g, T, P, 
      {
        if (!TEST_BIT (g->visited, P))
          return 1;
*************** elim_backward (elim_graph g, int T)
*** 1092,1098 ****
  {
    int P;
    SET_BIT (g->visited, T);
!   EXECUTE_IF_SET_IN_BITMAP (g->pred[T], 0, P,
      {
        if (!TEST_BIT (g->visited, P))
          {
--- 1148,1154 ----
  {
    int P;
    SET_BIT (g->visited, T);
!   FOR_EACH_ELIM_GRAPH_PRED (g, T, P, 
      {
        if (!TEST_BIT (g->visited, P))
          {
*************** elim_create (elim_graph g, int T)
*** 1118,1124 ****
      {
        U = create_temp (partition_to_var (g->map, T));
        insert_copy_on_edge (g->e, U, partition_to_var (g->map, T));
!       EXECUTE_IF_SET_IN_BITMAP (g->pred[T], 0, P,
  	{
  	  if (!TEST_BIT (g->visited, P))
  	    {
--- 1174,1180 ----
      {
        U = create_temp (partition_to_var (g->map, T));
        insert_copy_on_edge (g->e, U, partition_to_var (g->map, T));
!       FOR_EACH_ELIM_GRAPH_PRED (g, T, P, 
  	{
  	  if (!TEST_BIT (g->visited, P))
  	    {
*************** elim_create (elim_graph g, int T)
*** 1129,1139 ****
      }
    else
      {
!       S = bitmap_first_set_bit (g->succ[T]);
        if (S != -1)
  	{
  	  SET_BIT (g->visited, T);
- 	  bitmap_clear_bit (g->succ[T], S);
  	  insert_copy_on_edge (g->e, 
  			       partition_to_var (g->map, T), 
  			       partition_to_var (g->map, S));
--- 1185,1194 ----
      }
    else
      {
!       S = elim_graph_remove_succ_edge (g, T);
        if (S != -1)
  	{
  	  SET_BIT (g->visited, T);
  	  insert_copy_on_edge (g->e, 
  			       partition_to_var (g->map, T), 
  			       partition_to_var (g->map, S));
*************** static void
*** 1148,1154 ****
  eliminate_phi (edge e, int i, elim_graph g)
  {
    int num_nodes = 0;
!   int x, limit;
    basic_block B = e->dest;
  
  #if defined ENABLE_CHECKING
--- 1203,1209 ----
  eliminate_phi (edge e, int i, elim_graph g)
  {
    int num_nodes = 0;
!   int x;
    basic_block B = e->dest;
  
  #if defined ENABLE_CHECKING
*************** eliminate_phi (edge e, int i, elim_graph
*** 1158,1186 ****
      abort ();
  #endif
  
    num_nodes = num_var_partitions (g->map);
    g->e = e;
  
!   x = eliminate_build (g, B, i);
  
!   if (g->num_nodes != 0)
      {
        sbitmap_zero (g->visited);
!       g->top_of_stack = 0;
  
!       limit = g->num_nodes;
!       for (x = 0; limit; x++)
! 	 if (g->nodes[x])
! 	   {
! 	     limit--;
! 	     if (!TEST_BIT (g->visited, x))
! 	       elim_forward (g, x);
! 	   }
         
        sbitmap_zero (g->visited);
!       while (g->top_of_stack > 0)
  	{
! 	  x = g->stack[--(g->top_of_stack)];
  	  if (!TEST_BIT (g->visited, x))
  	    elim_create (g, x);
  	}
--- 1213,1246 ----
      abort ();
  #endif
  
+   /* Abnormal edges already have everything coalesced, or the coalescer
+      would have aborted.  */
+   if (e->flags & EDGE_ABNORMAL)
+     return;
+ 
    num_nodes = num_var_partitions (g->map);
    g->e = e;
  
!   eliminate_build (g, B, i);
  
!   if (elim_graph_size (g) != 0)
      {
        sbitmap_zero (g->visited);
!       VARRAY_POP_ALL (g->stack);
  
!       for (x = 0; x < elim_graph_size (g); x++)
!         {
! 	  tree var = VARRAY_TREE (g->nodes, x);
! 	  int p = var_to_partition (g->map, var);
! 	  if (!TEST_BIT (g->visited, p))
! 	    elim_forward (g, p);
! 	}
         
        sbitmap_zero (g->visited);
!       while (VARRAY_ACTIVE_SIZE (g->stack) > 0)
  	{
! 	  x = VARRAY_TOP_INT (g->stack);
! 	  VARRAY_POP (g->stack);
  	  if (!TEST_BIT (g->visited, x))
  	    elim_create (g, x);
  	}
*************** rewrite_out_of_ssa (tree fndecl, enum tr
*** 1656,1662 ****
    eliminate_extraneous_phis (map);
  
    /* Shrink the map to include only referenced variables.  */
!   compact_var_map (map, VARMAP_NORMAL);
  
    if (dump_file && (dump_flags & TDF_DETAILS))
      dump_var_map (dump_file, map);
--- 1716,1725 ----
    eliminate_extraneous_phis (map);
  
    /* Shrink the map to include only referenced variables.  */
!   if (flag_tree_combine_temps)
!     compact_var_map (map, VARMAP_NORMAL);
!   else
!     compact_var_map (map, VARMAP_NO_SINGLE_DEFS);
  
    if (dump_file && (dump_flags & TDF_DETAILS))
      dump_var_map (dump_file, map);
*************** rewrite_out_of_ssa (tree fndecl, enum tr
*** 1668,1673 ****
--- 1731,1738 ----
        fprintf (dump_file, "After Coalescing:\n");
        dump_var_map (dump_file, map);
      }
+   if (!flag_tree_combine_temps)
+     compact_var_map (map, VARMAP_NORMAL);
  
    /* This is the final var list, so assign real variables to the different
       partitions.  */




Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]