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]

Re: [tuples][patch] port pass_del_ssa to tuples


Now with the pass enabled :-)

2008-01-31  Rafael Espindola  <espindola@google.com>

* passes.c (init_optimization_passes): Enable pass_del_ssa.

* tree-outof-ssa.c (insert_copy_on_edge): Port to tuples.
    (eliminate_build): Likewise.
    (eliminate_virtual_phis): Likewise.
    (rewrite_trees): Likewise. Remove stmt_ann_t ann.
    (stmt_list): Changed from tree to gimple_seq.
    (identical_copies_p): Port to tuples.
    (identical_stmt_lists_p): Likewise.
    (init_analyze_edges_for_bb): Likewise.
    (fini_analyze_edges_for_bb): Likewise.
    (process_single_block_loop_latch): Likewise.
    (analyze_edges_for_bb): LIkewise.
    (remove_ssa_form): Likewise.
    (insert_backedge_copies):
    (rewrite_out_of_ssa):Likewise.
    (pass_del_ssa): flip works_with_tuples_p. Don't require PROP_alias.

  * tree-ssa-coalesce.c (build_ssa_conflict_graph): Port to tuples.
   (abnormal_corrupt): Port to tuples.
   (fail_abnormal_edge_coalesce): Port to tuples.
   (create_outofssa_var_map):Port to tuples.
   (coalesce_partitions): Port to tuples.

Cheers,
-- 
Rafael Avila de Espindola

Google Ireland Ltd.
Gordon House
Barrow Street
Dublin 4
Ireland

Registered in Dublin, Ireland
Registration Number: 368047
diff --git a/gcc/passes.c b/gcc/passes.c
index 5083db2..58083b9 100644
--- a/gcc/passes.c
+++ b/gcc/passes.c
@@ -692,7 +692,9 @@ init_optimization_passes (void)
       NEXT_PASS (pass_tail_calls);
       NEXT_PASS (pass_rename_ssa_copies);
       NEXT_PASS (pass_uncprop);
+#endif
       NEXT_PASS (pass_del_ssa);
+#if 0
       NEXT_PASS (pass_nrv);
       NEXT_PASS (pass_mark_used_blocks);
       NEXT_PASS (pass_cleanup_cfg_post_optimizing);
diff --git a/gcc/tree-outof-ssa.c b/gcc/tree-outof-ssa.c
index 7c110ac..69055a9 100644
--- a/gcc/tree-outof-ssa.c
+++ b/gcc/tree-outof-ssa.c
@@ -34,9 +34,6 @@ along with GCC; see the file COPYING3.  If not see
 #include "tree-pass.h"
 #include "toplev.h"
 
-
-/* FIXME tuples.  */
-#if 0
 /* Used to hold all the components required to do SSA PHI elimination.
    The node and pred/succ list is a simple linear list of nodes and
    edges represented as pairs of nodes.
@@ -141,9 +138,9 @@ create_temp (tree t)
 static void
 insert_copy_on_edge (edge e, tree dest, tree src)
 {
-  tree copy;
+  gimple copy;
 
-  copy = build_gimple_modify_stmt (dest, src);
+  copy = gimple_build_assign (dest, src);
   set_is_used (dest);
 
   if (TREE_CODE (src) == ADDR_EXPR)
@@ -157,11 +154,11 @@ insert_copy_on_edge (edge e, tree dest, tree src)
 	       "Inserting a copy on edge BB%d->BB%d :",
 	       e->src->index,
 	       e->dest->index);
-      print_generic_expr (dump_file, copy, dump_flags);
+      print_gimple_stmt (dump_file, copy, 0, dump_flags);
       fprintf (dump_file, "\n");
     }
 
-  bsi_insert_on_edge (e, copy);
+  gsi_insert_on_edge (e, copy);
 }
 
 
@@ -315,15 +312,17 @@ eliminate_name (elim_graph g, tree T)
 static void
 eliminate_build (elim_graph g, basic_block B)
 {
-  tree phi;
   tree T0, Ti;
   int p0, pi;
+  gimple_stmt_iterator *gsi;
 
   clear_elim_graph (g);
   
-  for (phi = phi_nodes (B); phi; phi = PHI_CHAIN (phi))
+  for (gsi = gsi_start (phi_nodes (B)); !gsi_end_p (gsi); gsi_next (gsi))
     {
-      T0 = var_to_partition_to_var (g->map, PHI_RESULT (phi));
+      gimple phi = gsi_stmt (gsi);
+
+      T0 = var_to_partition_to_var (g->map, gimple_phi_result (phi));
       
       /* Ignore results which are not in partitions.  */
       if (T0 == NULL_TREE)
@@ -614,20 +613,20 @@ static void
 eliminate_virtual_phis (void)
 {
   basic_block bb;
-  tree phi, next;
+  gimple_stmt_iterator *gsi;
 
   FOR_EACH_BB (bb)
     {
-      for (phi = phi_nodes (bb); phi; phi = next)
+      for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi); gsi_next (gsi))
         {
-	  next = PHI_CHAIN (phi);
-	  if (!is_gimple_reg (SSA_NAME_VAR (PHI_RESULT (phi))))
+	  gimple phi = gsi_stmt (gsi);
+	  if (!is_gimple_reg (SSA_NAME_VAR (gimple_phi_result (phi))))
 	    {
 #ifdef ENABLE_CHECKING
-	      int i;
+	      size_t i;
 	      /* There should be no arguments of this PHI which are in
 		 the partition list, or we get incorrect results.  */
-	      for (i = 0; i < PHI_NUM_ARGS (phi); i++)
+	      for (i = 0; i < gimple_phi_num_args (phi); i++)
 	        {
 		  tree arg = PHI_ARG_DEF (phi, i);
 		  if (TREE_CODE (arg) == SSA_NAME 
@@ -636,12 +635,12 @@ eliminate_virtual_phis (void)
 		      fprintf (stderr, "Argument of PHI is not virtual (");
 		      print_generic_expr (stderr, arg, TDF_SLIM);
 		      fprintf (stderr, "), but the result is :");
-		      print_generic_stmt (stderr, phi, TDF_SLIM);
+		      print_gimple_stmt (stderr, phi, 0, TDF_SLIM);
 		      internal_error ("SSA corruption");
 		    }
 		}
 #endif
-	      remove_phi_node (phi, NULL_TREE, true);
+	      remove_phi_node (phi, true);
 	    }
 	}
     }
@@ -659,9 +658,9 @@ rewrite_trees (var_map map, tree *values)
 {
   elim_graph g;
   basic_block bb;
-  block_stmt_iterator si;
+  gimple_stmt_iterator *gsi;
   edge e;
-  tree phi;
+  gimple_seq phi;
   bool changed;
  
 #ifdef ENABLE_CHECKING
@@ -670,14 +669,14 @@ rewrite_trees (var_map map, tree *values)
      create incorrect code.  */
   FOR_EACH_BB (bb)
     {
-      tree phi;
-      for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
+      for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi); gsi_next (gsi))
 	{
-	  tree T0 = var_to_partition_to_var (map, PHI_RESULT (phi));
+	  gimple phi = gsi_stmt (gsi);
+	  tree T0 = var_to_partition_to_var (map, gimple_phi_result (phi));
 	  if (T0 == NULL_TREE)
 	    {
-	      int i;
-	      for (i = 0; i < PHI_NUM_ARGS (phi); i++)
+	      size_t i;
+	      for (i = 0; i < gimple_phi_num_args (phi); i++)
 		{
 		  tree arg = PHI_ARG_DEF (phi, i);
 
@@ -687,7 +686,7 @@ rewrite_trees (var_map map, tree *values)
 		      fprintf (stderr, "Argument of PHI is in a partition :(");
 		      print_generic_expr (stderr, arg, TDF_SLIM);
 		      fprintf (stderr, "), but the result is not :");
-		      print_generic_stmt (stderr, phi, TDF_SLIM);
+		      print_gimple_stmt (stderr, phi, 0, TDF_SLIM);
 		      internal_error ("SSA corruption");
 		    }
 		}
@@ -701,21 +700,18 @@ rewrite_trees (var_map map, tree *values)
   g->map = map;
   FOR_EACH_BB (bb)
     {
-      for (si = bsi_start (bb); !bsi_end_p (si); )
+      for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); )
 	{
-	  tree stmt = bsi_stmt (si);
+	  gimple stmt = gsi_stmt (gsi);
 	  use_operand_p use_p, copy_use_p;
 	  def_operand_p def_p;
 	  bool remove = false, is_copy = false;
 	  int num_uses = 0;
-	  stmt_ann_t ann;
 	  ssa_op_iter iter;
 
-	  ann = stmt_ann (stmt);
 	  changed = false;
 
-	  if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT 
-	      && (TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)) == SSA_NAME))
+	  if (gimple_assign_copy_p (stmt))
 	    is_copy = true;
 
 	  copy_use_p = NULL_USE_OPERAND_P;
@@ -759,13 +755,13 @@ rewrite_trees (var_map map, tree *values)
 
 	  /* Remove any stmts marked for removal.  */
 	  if (remove)
-	    bsi_remove (&si, true);
+	    gsi_remove (gsi, true);
 	  else
 	    {
 	      if (changed)
 		if (maybe_clean_or_replace_eh_stmt (stmt, stmt))
-		  tree_purge_dead_eh_edges (bb);
-	      bsi_next (&si);
+		  gimple_purge_dead_eh_edges (bb);
+	      gsi_next (gsi);
 	    }
 	}
 
@@ -784,7 +780,7 @@ rewrite_trees (var_map map, tree *values)
 /* These are the local work structures used to determine the best place to 
    insert the copies that were placed on edges by the SSA->normal pass..  */
 static VEC(edge,heap) *edge_leader;
-static VEC(tree,heap) *stmt_list;
+static VEC(gimple_seq,heap) *stmt_list;
 static bitmap leader_has_match = NULL;
 static edge leader_match = NULL;
 
@@ -803,22 +799,19 @@ same_stmt_list_p (edge e)
 /* Return TRUE if S1 and S2 are equivalent copies.  */
 
 static inline bool
-identical_copies_p (const_tree s1, const_tree s2)
+identical_copies_p (const_gimple s1, const_gimple s2)
 {
 #ifdef ENABLE_CHECKING
-  gcc_assert (TREE_CODE (s1) == GIMPLE_MODIFY_STMT);
-  gcc_assert (TREE_CODE (s2) == GIMPLE_MODIFY_STMT);
-  gcc_assert (DECL_P (GIMPLE_STMT_OPERAND (s1, 0)));
-  gcc_assert (DECL_P (GIMPLE_STMT_OPERAND (s2, 0)));
+  gcc_assert (gimple_code (s1) == GIMPLE_ASSIGN);
+  gcc_assert (gimple_code (s2) == GIMPLE_ASSIGN);
+  gcc_assert (DECL_P (gimple_assign_lhs (s1)));
+  gcc_assert (DECL_P (gimple_assign_lhs (s2)));
 #endif
 
-  if (GIMPLE_STMT_OPERAND (s1, 0) != GIMPLE_STMT_OPERAND (s2, 0))
+  if (gimple_assign_lhs (s1) != gimple_assign_lhs (s2))
     return false;
 
-  s1 = GIMPLE_STMT_OPERAND (s1, 1);
-  s2 = GIMPLE_STMT_OPERAND (s2, 1);
-
-  if (s1 != s2)
+  if (gimple_assign_rhs1 (s1) != gimple_assign_rhs1 (s2))
     return false;
 
   return true;
@@ -831,22 +824,19 @@ identical_copies_p (const_tree s1, const_tree s2)
 static inline bool 
 identical_stmt_lists_p (const_edge e1, const_edge e2)
 {
-  tree t1 = PENDING_STMT (e1);
-  tree t2 = PENDING_STMT (e2);
-  tree_stmt_iterator tsi1, tsi2;
-
-  gcc_assert (TREE_CODE (t1) == STATEMENT_LIST);
-  gcc_assert (TREE_CODE (t2) == STATEMENT_LIST);
+  gimple_seq t1 = PENDING_STMT (e1);
+  gimple_seq t2 = PENDING_STMT (e2);
+  gimple_stmt_iterator *gsi1, *gsi2;
 
-  for (tsi1 = tsi_start (t1), tsi2 = tsi_start (t2);
-       !tsi_end_p (tsi1) && !tsi_end_p (tsi2); 
-       tsi_next (&tsi1), tsi_next (&tsi2))
+  for (gsi1 = gsi_start (t1), gsi2 = gsi_start (t2);
+       !gsi_end_p (gsi1) && !gsi_end_p (gsi2); 
+       gsi_next (gsi1), gsi_next (gsi2))
     {
-      if (!identical_copies_p (tsi_stmt (tsi1), tsi_stmt (tsi2)))
+      if (!identical_copies_p (gsi_stmt (gsi1), gsi_stmt (gsi2)))
         break;
     }
 
-  if (!tsi_end_p (tsi1) || ! tsi_end_p (tsi2))
+  if (!gsi_end_p (gsi1) || !gsi_end_p (gsi2))
     return false;
 
   return true;
@@ -859,7 +849,7 @@ static void
 init_analyze_edges_for_bb (void)
 {
   edge_leader = VEC_alloc (edge, heap, 25);
-  stmt_list = VEC_alloc (tree, heap, 25);
+  stmt_list = VEC_alloc (gimple_seq, heap, 25);
   leader_has_match = BITMAP_ALLOC (NULL);
 }
 
@@ -870,7 +860,7 @@ static void
 fini_analyze_edges_for_bb (void)
 {
   VEC_free (edge, heap, edge_leader);
-  VEC_free (tree, heap, stmt_list);
+  VEC_free (gimple_seq, heap, stmt_list);
   BITMAP_FREE (leader_has_match);
 }
 
@@ -902,13 +892,14 @@ contains_tree_r (tree * tp, int *walk_subtrees, void *data)
 static bool
 process_single_block_loop_latch (edge single_edge)
 {
-  tree stmts;
+  gimple_seq stmts;
   basic_block b_exit, b_pheader, b_loop = single_edge->src;
   edge_iterator ei;
   edge e;
-  block_stmt_iterator bsi, bsi_exit;
-  tree_stmt_iterator tsi;
-  tree expr, stmt;
+  gimple_stmt_iterator *gsi, *gsi_exit;
+  gimple_stmt_iterator *tsi;
+  tree expr;
+  gimple stmt;
   unsigned int count = 0;
 
   if (single_edge == NULL || (single_edge->dest != single_edge->src)
@@ -941,29 +932,31 @@ process_single_block_loop_latch (edge single_edge)
   if (b_exit == b_pheader || b_exit == b_loop || b_pheader == b_loop)
     return false;
 
-  bsi_exit = bsi_after_labels (b_exit);
+  gsi_exit = gsi_after_labels (b_exit);
 
   /* Get the last stmt in the loop body.  */
-  bsi = bsi_last (single_edge->src);
-  stmt = bsi_stmt (bsi);
+  gsi = gsi_last_bb (single_edge->src);
+  stmt = gsi_stmt (gsi);
 
-  if (TREE_CODE (stmt) != COND_EXPR)
+  if (gimple_code (stmt) != GIMPLE_COND)
     return false;
 
-  expr = COND_EXPR_COND (stmt);
+
+  expr = build2 (gimple_cond_code (stmt), boolean_type_node,
+                 gimple_cond_lhs (stmt), gimple_cond_rhs (stmt));
   /* Iterate over the insns on the latch and count them.  */
-  for (tsi = tsi_start (stmts); !tsi_end_p (tsi); tsi_next (&tsi))
+  for (tsi = gsi_start (stmts); !gsi_end_p (tsi); gsi_next (tsi))
     {
-      tree stmt1 = tsi_stmt (tsi);
+      gimple stmt1 = gsi_stmt (tsi);
       tree var;
 
       count++;
       /* Check that the condition does not contain any new definition
          created in the latch as the stmts from the latch intended
          to precede it.  */
-      if (TREE_CODE (stmt1) != GIMPLE_MODIFY_STMT)
+      if (gimple_code (stmt1) != GIMPLE_ASSIGN)
         return false;
-      var = GIMPLE_STMT_OPERAND (stmt1, 0);
+      var = gimple_assign_lhs (stmt1);
       if (TREE_THIS_VOLATILE (var)
 	  || TYPE_VOLATILE (TREE_TYPE (var))
 	  || walk_tree (&expr, contains_tree_r, var, NULL))
@@ -999,25 +992,26 @@ process_single_block_loop_latch (edge single_edge)
      var = tmp_var;
      ... 
    */
-  for (tsi = tsi_start (stmts); !tsi_end_p (tsi); tsi_next (&tsi))
+  for (tsi = gsi_start (stmts); !gsi_end_p (tsi); gsi_next (tsi))
     {
-      tree stmt1 = tsi_stmt (tsi);
-      tree var, tmp_var, copy;
+      gimple stmt1 = gsi_stmt (tsi);
+      tree var, tmp_var;
+      gimple copy;
 
       /* Create a new variable to load back the value of var in case
          we exit the loop.  */
-      var = GIMPLE_STMT_OPERAND (stmt1, 0);
+      var = gimple_assign_lhs (stmt1);
       tmp_var = create_temp (var);
-      copy = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (tmp_var), tmp_var, var);
+      copy = gimple_build_assign (tmp_var, var);
       set_is_used (tmp_var);
-      bsi_insert_before (&bsi, copy, BSI_SAME_STMT);
-      copy = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (tmp_var), var, tmp_var);
-      bsi_insert_before (&bsi_exit, copy, BSI_SAME_STMT);
+      gsi_insert_before (gsi, copy, GSI_SAME_STMT);
+      copy = gimple_build_assign (var, tmp_var);
+      gsi_insert_before (gsi_exit, copy, GSI_SAME_STMT);
     }
 
   PENDING_STMT (single_edge) = 0;
   /* Insert the new stmts to the loop body.  */
-  bsi_insert_before (&bsi, stmts, BSI_NEW_STMT);
+  gsi_insert_seq_before (gsi, stmts, GSI_NEW_STMT);
 
   if (dump_file)
     fprintf (dump_file,
@@ -1038,8 +1032,8 @@ analyze_edges_for_bb (basic_block bb)
   int count;
   unsigned int x;
   bool have_opportunity;
-  block_stmt_iterator bsi;
-  tree stmt;
+  gimple_stmt_iterator *gsi;
+  gimple stmt;
   edge single_edge = NULL;
   bool is_label;
   edge leader;
@@ -1061,7 +1055,7 @@ analyze_edges_for_bb (basic_block bb)
     {
       FOR_EACH_EDGE (e, ei, bb->preds)
 	if (PENDING_STMT (e))
-	  bsi_commit_one_edge_insert (e, NULL);
+	  gsi_commit_one_edge_insert (e, NULL);
       return;
     }
 
@@ -1074,18 +1068,18 @@ analyze_edges_for_bb (basic_block bb)
 	  gcc_assert (!(e->flags & EDGE_ABNORMAL));
 	  if (e->flags & EDGE_FALLTHRU)
 	    {
-	      bsi = bsi_start (e->src);
-	      if (!bsi_end_p (bsi))
+	      gsi = gsi_start_bb (e->src);
+	      if (!gsi_end_p (gsi))
 	        {
-		  stmt = bsi_stmt (bsi);
-		  bsi_next (&bsi);
-		  gcc_assert (stmt != NULL_TREE);
-		  is_label = (TREE_CODE (stmt) == LABEL_EXPR);
+		  stmt = gsi_stmt (gsi);
+		  gsi_next (gsi);
+		  gcc_assert (stmt != NULL);
+		  is_label = (gimple_code (stmt) == GIMPLE_LABEL);
 		  /* Punt if it has non-label stmts, or isn't local.  */
-		  if (!is_label || DECL_NONLOCAL (TREE_OPERAND (stmt, 0)) 
-		      || !bsi_end_p (bsi))
+		  if (!is_label || DECL_NONLOCAL (gimple_label_label (stmt)) 
+		      || !gsi_end_p (gsi))
 		    {
-		      bsi_commit_one_edge_insert (e, NULL);
+		      gsi_commit_one_edge_insert (e, NULL);
 		      continue;
 		    }
 		}
@@ -1103,7 +1097,7 @@ analyze_edges_for_bb (basic_block bb)
        /* Add stmts to the edge unless processed specially as a
           single-block loop latch edge. */
        if (!process_single_block_loop_latch (single_edge))
-         bsi_commit_one_edge_insert (single_edge, NULL);
+         gsi_commit_one_edge_insert (single_edge, NULL);
       }
       return;
     }
@@ -1111,7 +1105,7 @@ analyze_edges_for_bb (basic_block bb)
   /* Ensure that we have empty worklists.  */
 #ifdef ENABLE_CHECKING
   gcc_assert (VEC_length (edge, edge_leader) == 0);
-  gcc_assert (VEC_length (tree, stmt_list) == 0);
+  gcc_assert (VEC_length (gimple_seq, stmt_list) == 0);
   gcc_assert (bitmap_empty_p (leader_has_match));
 #endif
 
@@ -1144,7 +1138,7 @@ analyze_edges_for_bb (basic_block bb)
 	  if (!found)
 	    {
 	      VEC_safe_push (edge, heap, edge_leader, e);
-	      VEC_safe_push (tree, heap, stmt_list, PENDING_STMT (e));
+	      VEC_safe_push (gimple_seq, heap, stmt_list, PENDING_STMT (e));
 	    }
 	}
      }
@@ -1153,9 +1147,9 @@ analyze_edges_for_bb (basic_block bb)
   if (!have_opportunity)
     {
       for (x = 0; VEC_iterate (edge, edge_leader, x, leader); x++)
-	bsi_commit_one_edge_insert (leader, NULL);
+	gsi_commit_one_edge_insert (leader, NULL);
       VEC_truncate (edge, edge_leader, 0);
-      VEC_truncate (tree, stmt_list, 0);
+      VEC_truncate (gimple_seq, stmt_list, 0);
       bitmap_clear (leader_has_match);
       return;
     }
@@ -1170,8 +1164,8 @@ analyze_edges_for_bb (basic_block bb)
     if (bitmap_bit_p (leader_has_match, x))
       {
 	edge new_edge;
-	block_stmt_iterator bsi;
-	tree curr_stmt_list;
+	gimple_stmt_iterator *gsi;
+	gimple_seq curr_stmt_list;
 
 	leader_match = leader;
 
@@ -1181,7 +1175,7 @@ analyze_edges_for_bb (basic_block bb)
 	   and use the saved stmt list.  */
 	PENDING_STMT (leader) = NULL;
 	leader->aux = leader;
-	curr_stmt_list = VEC_index (tree, stmt_list, x);
+	curr_stmt_list = VEC_index (gimple_seq, stmt_list, x);
 
         new_edge = make_forwarder_block (leader->dest, same_stmt_list_p, 
 					 NULL);
@@ -1191,7 +1185,7 @@ analyze_edges_for_bb (basic_block bb)
 	    fprintf (dump_file, "Splitting BB %d for Common stmt list.  ", 
 		     leader->dest->index);
 	    fprintf (dump_file, "Original block is now BB%d.\n", bb->index);
-	    print_generic_stmt (dump_file, curr_stmt_list, TDF_VOPS);
+	    print_gimple_seq (dump_file, curr_stmt_list, 0, TDF_VOPS);
 	  }
 
 	FOR_EACH_EDGE (e, ei, new_edge->src->preds)
@@ -1202,22 +1196,22 @@ analyze_edges_for_bb (basic_block bb)
 		       e->src->index, e->dest->index);
 	  }
 
-	bsi = bsi_last (leader->dest);
-	bsi_insert_after (&bsi, curr_stmt_list, BSI_NEW_STMT);
+	gsi = gsi_last_bb (leader->dest);
+	gsi_insert_seq_after (gsi, curr_stmt_list, GSI_NEW_STMT);
 
 	leader_match = NULL;
 	/* We should never get a new block now.  */
       }
     else
       {
-	PENDING_STMT (leader) = VEC_index (tree, stmt_list, x);
-	bsi_commit_one_edge_insert (leader, NULL);
+	PENDING_STMT (leader) = VEC_index (gimple_seq, stmt_list, x);
+	gsi_commit_one_edge_insert (leader, NULL);
       }
 
    
   /* Clear the working data structures.  */
   VEC_truncate (edge, edge_leader, 0);
-  VEC_truncate (tree, stmt_list, 0);
+  VEC_truncate (gimple_seq, stmt_list, 0);
   bitmap_clear (leader_has_match);
 }
 
@@ -1297,9 +1291,10 @@ static void
 remove_ssa_form (bool perform_ter)
 {
   basic_block bb;
-  tree phi, next;
+  gimple phi;
   tree *values = NULL;
   var_map map;
+  gimple_stmt_iterator *gsi;
 
   map = coalesce_ssa_name ();
 
@@ -1315,9 +1310,15 @@ remove_ssa_form (bool perform_ter)
 
   if (perform_ter)
     {
+
+      /* FIXME tuples */
+#if 0
       values = find_replaceable_exprs (map);
       if (values && dump_file && (dump_flags & TDF_DETAILS))
 	dump_replaceable_exprs (dump_file, values);
+#else
+      values = NULL;
+#endif
     }
 
   /* Assign real variables to the partitions now.  */
@@ -1337,10 +1338,14 @@ remove_ssa_form (bool perform_ter)
   /* Remove PHI nodes which have been translated back to real variables.  */
   FOR_EACH_BB (bb)
     {
-      for (phi = phi_nodes (bb); phi; phi = next)
+      for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi);)
 	{
-	  next = PHI_CHAIN (phi);
-	  remove_phi_node (phi, NULL_TREE, true);
+	  phi = gsi_stmt (gsi);
+
+          /* Update iterator before removing phi */
+          gsi_next (gsi);
+
+	  remove_phi_node (phi, true);
 	}
     }
 
@@ -1364,25 +1369,25 @@ static void
 insert_backedge_copies (void)
 {
   basic_block bb;
+  gimple_stmt_iterator *gsi;
 
   FOR_EACH_BB (bb)
     {
-      tree phi;
-
-      for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
+      for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi); gsi_next (gsi))
 	{
-	  tree result = PHI_RESULT (phi);
+	  gimple phi = gsi_stmt (gsi);
+	  tree result = gimple_phi_result (phi);
 	  tree result_var;
-	  int i;
+	  size_t i;
 
 	  if (!is_gimple_reg (result))
 	    continue;
 
 	  result_var = SSA_NAME_VAR (result);
-	  for (i = 0; i < PHI_NUM_ARGS (phi); i++)
+	  for (i = 0; i < gimple_phi_num_args (phi); i++)
 	    {
-	      tree arg = PHI_ARG_DEF (phi, i);
-	      edge e = PHI_ARG_EDGE (phi, i);
+	      tree arg = gimple_phi_arg_def (phi, i);
+	      edge e = gimple_phi_arg_edge (phi, i);
 
 	      /* If the argument is not an SSA_NAME, then we will need a 
 		 constant initialization.  If the argument is an SSA_NAME with
@@ -1392,12 +1397,13 @@ insert_backedge_copies (void)
 		  && (TREE_CODE (arg) != SSA_NAME
 		      || SSA_NAME_VAR (arg) != result_var))
 		{
-		  tree stmt, name, last = NULL;
-		  block_stmt_iterator bsi;
+		  tree name;
+		  gimple stmt, last = NULL;
+		  gimple_stmt_iterator *gsi2;
 
-		  bsi = bsi_last (PHI_ARG_EDGE (phi, i)->src);
-		  if (!bsi_end_p (bsi))
-		    last = bsi_stmt (bsi);
+		  gsi2 = gsi_last_bb (gimple_phi_arg_edge (phi, i)->src);
+		  if (!gsi_end_p (gsi2))
+		    last = gsi_stmt (gsi2);
 
 		  /* In theory the only way we ought to get back to the
 		     start of a loop should be with a COND_EXPR or GOTO_EXPR.
@@ -1418,24 +1424,23 @@ insert_backedge_copies (void)
 
 		  /* Create a new instance of the underlying variable of the 
 		     PHI result.  */
-		  stmt = build_gimple_modify_stmt (NULL_TREE,
-						   PHI_ARG_DEF (phi, i));
+		  stmt = gimple_build_assign (NULL, gimple_phi_arg_def (phi,
+                                                                        i));
 		  name = make_ssa_name (result_var, stmt);
-		  GIMPLE_STMT_OPERAND (stmt, 0) = name;
+		  gimple_assign_set_lhs (stmt, name);
 
 		  /* Insert the new statement into the block and update
 		     the PHI node.  */
 		  if (last && stmt_ends_bb_p (last))
-		    bsi_insert_before (&bsi, stmt, BSI_NEW_STMT);
+		    gsi_insert_before (gsi2, stmt, GSI_NEW_STMT);
 		  else
-		    bsi_insert_after (&bsi, stmt, BSI_NEW_STMT);
+		    gsi_insert_after (gsi2, stmt, GSI_NEW_STMT);
 		  SET_PHI_ARG_DEF (phi, i, name);
 		}
 	    }
 	}
     }
 }
-#endif
 
 /* Take the current function out of SSA form, translating PHIs as described in
    R. Morgan, ``Building an Optimizing Compiler'',
@@ -1444,8 +1449,6 @@ insert_backedge_copies (void)
 static unsigned int
 rewrite_out_of_ssa (void)
 {
-  /* FIXME tuples.  */
-#if 0
   /* If elimination of a PHI requires inserting a copy on a backedge,
      then we will have to split the backedge which has numerous
      undesirable performance effects.
@@ -1457,18 +1460,15 @@ rewrite_out_of_ssa (void)
   eliminate_virtual_phis ();
 
   if (dump_file && (dump_flags & TDF_DETAILS))
-    dump_tree_cfg (dump_file, dump_flags & ~TDF_DETAILS);
+    gimple_dump_cfg (dump_file, dump_flags & ~TDF_DETAILS);
 
   remove_ssa_form (flag_tree_ter && !flag_mudflap);
 
   if (dump_file && (dump_flags & TDF_DETAILS))
-    dump_tree_cfg (dump_file, dump_flags & ~TDF_DETAILS);
+    gimple_dump_cfg (dump_file, dump_flags & ~TDF_DETAILS);
 
   cfun->gimple_df->in_ssa_p = false;
   return 0;
-#else
-  gimple_unreachable ();
-#endif
 }
 
 
@@ -1483,7 +1483,14 @@ struct tree_opt_pass pass_del_ssa =
   NULL,					/* next */
   0,					/* static_pass_number */
   TV_TREE_SSA_TO_NORMAL,		/* tv_id */
+
+  /* FIXME tupless */
+#if 0
   PROP_cfg | PROP_ssa | PROP_alias,	/* properties_required */
+#else
+  PROP_cfg | PROP_ssa,	/* properties_required */
+#endif
+
   0,					/* properties_provided */
   /* ??? If TER is enabled, we also kill gimple.  */
   PROP_ssa,				/* properties_destroyed */
@@ -1493,5 +1500,5 @@ struct tree_opt_pass pass_del_ssa =
   | TODO_ggc_collect
   | TODO_remove_unused_locals,		/* todo_flags_finish */
   0					/* letter */
-  ,0					/* works_with_tuples_p */
+  ,1					/* works_with_tuples_p */
 };
diff --git a/gcc/tree-ssa-coalesce.c b/gcc/tree-ssa-coalesce.c
index a47c247..6698d70 100644
--- a/gcc/tree-ssa-coalesce.c
+++ b/gcc/tree-ssa-coalesce.c
@@ -33,8 +33,6 @@ along with GCC; see the file COPYING3.  If not see
 #include "toplev.h"
 
 
-/* FIXME tuples.  */
-#if 0
 /* This set of routines implements a coalesce_list.  This is an object which
    is used to track pairs of ssa_names which are desirable to coalesce
    together to avoid copies.  Costs are associated with each pair, and when 
@@ -842,16 +840,15 @@ build_ssa_conflict_graph (tree_live_info_p liveinfo)
 
   FOR_EACH_BB (bb)
     {
-      block_stmt_iterator bsi;
-      tree phi;
+      gimple_stmt_iterator *gsi;
 
       /* Start with live on exit temporaries.  */
       live_track_init (live, live_on_exit (liveinfo, bb));
 
-      for (bsi = bsi_last (bb); !bsi_end_p (bsi); bsi_prev (&bsi))
+      for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (gsi))
         {
 	  tree var;
-	  tree stmt = bsi_stmt (bsi);
+	  gimple stmt = gsi_stmt (gsi);
 
 	  /* A copy between 2 partitions does not introduce an interference 
 	     by itself.  If they did, you would never be able to coalesce 
@@ -860,12 +857,14 @@ build_ssa_conflict_graph (tree_live_info_p liveinfo)
 	     
 	     This is handled by simply removing the SRC of the copy from the 
 	     live list, and processing the stmt normally.  */
-	  if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
+	  if (gimple_code (stmt) == GIMPLE_ASSIGN)
 	    {
-	      tree lhs = GIMPLE_STMT_OPERAND (stmt, 0);
-	      tree rhs = GIMPLE_STMT_OPERAND (stmt, 1);
-	      if (TREE_CODE (lhs) == SSA_NAME && TREE_CODE (rhs) == SSA_NAME)
-		live_track_clear_var (live, rhs);
+	      tree lhs = gimple_assign_lhs (stmt);
+	      tree rhs1 = gimple_assign_rhs1 (stmt);
+	      if (get_gimple_rhs_num_ops (gimple_assign_subcode (stmt)) == 1
+                  && TREE_CODE (lhs) == SSA_NAME
+                  && TREE_CODE (rhs1) == SSA_NAME)
+		live_track_clear_var (live, rhs1);
 	    }
 
 	  FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_DEF)
@@ -881,8 +880,9 @@ build_ssa_conflict_graph (tree_live_info_p liveinfo)
 	 There must be a conflict recorded between the result of the PHI and 
 	 any variables that are live.  Otherwise the out-of-ssa translation 
 	 may create incorrect code.  */
-      for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
+      for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi); gsi_next (gsi))
 	{
+	  gimple phi = gsi_stmt (gsi);
 	  tree result = PHI_RESULT (phi);
 	  if (live_track_live_p (live, result))
 	    live_track_process_def (live, result, graph);
@@ -916,11 +916,11 @@ print_exprs (FILE *f, const char *str1, tree expr1, const char *str2,
    printed and compilation is then terminated.  */
 
 static inline void
-abnormal_corrupt (tree phi, int i)
+abnormal_corrupt (gimple phi, int i)
 {
-  edge e = PHI_ARG_EDGE (phi, i);
-  tree res = PHI_RESULT (phi);
-  tree arg = PHI_ARG_DEF (phi, i);
+  edge e = gimple_phi_arg_edge (phi, i);
+  tree res = gimple_phi_result (phi);
+  tree arg = gimple_phi_arg_def (phi, i);
 
   fprintf (stderr, " Corrupt SSA across abnormal edge BB%d->BB%d\n",
 	   e->src->index, e->dest->index);
@@ -960,10 +960,10 @@ fail_abnormal_edge_coalesce (int x, int y)
 static var_map
 create_outofssa_var_map (coalesce_list_p cl, bitmap used_in_copy)
 {
-  block_stmt_iterator bsi;
+  gimple_stmt_iterator *gsi;
   basic_block bb;
   tree var;
-  tree stmt;
+  gimple stmt;
   tree first;
   var_map map;
   ssa_op_iter iter;
@@ -982,24 +982,25 @@ create_outofssa_var_map (coalesce_list_p cl, bitmap used_in_copy)
 
   FOR_EACH_BB (bb)
     {
-      tree phi, arg;
+      tree arg;
 
-      for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
+      for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi); gsi_next (gsi))
 	{
-	  int i;
+	  gimple phi = gsi_stmt (gsi);
+	  size_t i;
 	  int ver;
 	  tree res;
 	  bool saw_copy = false;
 
-	  res = PHI_RESULT (phi);
+	  res = gimple_phi_result (phi);
 	  ver = SSA_NAME_VERSION (res);
 	  register_ssa_partition (map, res);
 
 	  /* Register ssa_names and coalesces between the args and the result 
 	     of all PHI.  */
-	  for (i = 0; i < PHI_NUM_ARGS (phi); i++)
+	  for (i = 0; i < gimple_phi_num_args (phi); i++)
 	    {
-	      edge e = PHI_ARG_EDGE (phi, i);
+	      edge e = gimple_phi_arg_edge (phi, i);
 	      arg = PHI_ARG_DEF (phi, i);
 	      if (TREE_CODE (arg) == SSA_NAME)
 		register_ssa_partition (map, arg);
@@ -1025,27 +1026,29 @@ create_outofssa_var_map (coalesce_list_p cl, bitmap used_in_copy)
 	    bitmap_set_bit (used_in_copy, ver);
 	}
 
-      for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
+      for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (gsi))
         {
-	  stmt = bsi_stmt (bsi);
+	  stmt = gsi_stmt (gsi);
 
 	  /* Register USE and DEF operands in each statement.  */
 	  FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, (SSA_OP_DEF|SSA_OP_USE))
 	    register_ssa_partition (map, var);
 
 	  /* Check for copy coalesces.  */
-	  switch (TREE_CODE (stmt))
+	  switch (gimple_code (stmt))
 	    {
-	    case GIMPLE_MODIFY_STMT:
+	    case GIMPLE_ASSIGN:
 	      {
-		tree op1 = GIMPLE_STMT_OPERAND (stmt, 0);
-		tree op2 = GIMPLE_STMT_OPERAND (stmt, 1);
-		if (TREE_CODE (op1) == SSA_NAME 
-		    && TREE_CODE (op2) == SSA_NAME
-		    && SSA_NAME_VAR (op1) == SSA_NAME_VAR (op2))
+		tree lhs = gimple_assign_lhs (stmt);
+		tree rhs1 = gimple_assign_rhs1 (stmt);
+
+		if (get_gimple_rhs_num_ops (gimple_assign_subcode (stmt)) == 1
+                    && TREE_CODE (lhs) == SSA_NAME
+		    && TREE_CODE (rhs1) == SSA_NAME
+		    && SSA_NAME_VAR (lhs) == SSA_NAME_VAR (rhs1))
 		  {
-		    v1 = SSA_NAME_VERSION (op1);
-		    v2 = SSA_NAME_VERSION (op2);
+		    v1 = SSA_NAME_VERSION (lhs);
+		    v2 = SSA_NAME_VERSION (rhs1);
 		    cost = coalesce_cost_bb (bb);
 		    add_coalesce (cl, v1, v2, cost);
 		    bitmap_set_bit (used_in_copy, v1);
@@ -1054,18 +1057,22 @@ create_outofssa_var_map (coalesce_list_p cl, bitmap used_in_copy)
 	      }
 	      break;
 
-	    case ASM_EXPR:
+	    case GIMPLE_ASM:
 	      {
 		unsigned long noutputs, i;
+		unsigned long ninputs;
 		tree *outputs, link;
-		noutputs = list_length (ASM_OUTPUTS (stmt));
+		noutputs = gimple_asm_noutputs (stmt);
+		ninputs = gimple_asm_ninputs (stmt);
 		outputs = (tree *) alloca (noutputs * sizeof (tree));
-		for (i = 0, link = ASM_OUTPUTS (stmt); link;
-		     ++i, link = TREE_CHAIN (link))
+		for (i = 0; i < noutputs; ++i) {
+		  link = gimple_asm_output_op (stmt, i);
 		  outputs[i] = TREE_VALUE (link);
+                }
 
-		for (link = ASM_INPUTS (stmt); link; link = TREE_CHAIN (link))
+		for (i = 0; i < ninputs; ++i)
 		  {
+		    link = gimple_asm_input_op (stmt, i);
 		    const char *constraint
 		      = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
 		    tree input = TREE_VALUE (link);
@@ -1248,7 +1255,7 @@ coalesce_partitions (var_map map, ssa_conflicts_p graph, coalesce_list_p cl,
 		     FILE *debug)
 {
   int x = 0, y = 0;
-  tree var1, var2, phi;
+  tree var1, var2;
   int cost;
   basic_block bb;
   edge e;
@@ -1263,8 +1270,11 @@ coalesce_partitions (var_map map, ssa_conflicts_p graph, coalesce_list_p cl,
       FOR_EACH_EDGE (e, ei, bb->preds)
 	if (e->flags & EDGE_ABNORMAL)
 	  {
-	    for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
+	    gimple_stmt_iterator *gsi;
+	    for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi);
+		 gsi_next (gsi))
 	      {
+		gimple phi = gsi_stmt (gsi);
 		tree res = PHI_RESULT (phi);
 	        tree arg = PHI_ARG_DEF (phi, e->dest_idx);
 		int v1 = SSA_NAME_VERSION (res);
@@ -1388,4 +1398,3 @@ coalesce_ssa_name (void)
 
   return map;
 }
-#endif

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