2005-04-05 Andrew MacLeod <amacleod@redhat.com>

	* lambda-code.c (lambda_loopnest_to_gcc_loopnest): Use update_stmt.
	Use immediate use iterator.
	(stmt_is_bumper_for_loop): Use immediate use iterator.
	* predict.c (strip_builtin_expect): Use update_stmt.
	* tree-cfg.c (update_modified_stmts): New. Call update_stmt_if_modified
	on all elements of a STATEMENT_LIST.
	(bsi_insert_before, bsi_insert_after): Call update_modified_stmts.
	(bsi_remove): Remove imm_use links and mark the stmt as modified.
	(bsi_replace): Mark stmt as modified and the update it.
	* tree-complex.c (update_complex_assignment): Call mark_stmt_modified.
	(expand_complex_libcal): Call update_stmt.
	(expand_complex_comparison): Call mark_stmt_modified.
	(expand_complex_operations_1): Call update_stmt_if_modified.
	(expand_vector_operations_1): Call mark_stmt_modified.
	* tree-dfa.c (compute_immediate_uses, free_df_for_stmt, free_df,
	compute_immediate_uses_for_phi, compute_immediate_uses_for_stmt,
	add_immediate_use, redirect_immediate_use,
	redirect_immediate_uses, dump_immediate_uses, debug_immediate_uses,
	dump_immediate_uses_for, debug_immediate_uses_for): Delete.
	(mark_new_vars_to_rename): Call update_stmt.
	* tree-dump.c (dump_option_value_in): Add "stmtaddr".
	* tree-flow-inline.h (modify_stmt): Rename to mark_stmt_modified.
	Ignore PHI nodes.
	(unmodify_stmt): Delete.
	(update_stmt): New.  Force an update of a stmt.
	(update_stmt_if_modified): update a stmt if it is out of date.
	(get_stmt_operands): Verify stmt is NOT modified.
	(stmt_modified_p): Update comment.
	(delink_imm_use): Remove a use node from its immuse list.
	(link_imm_use_to_list): Link a use node to a specific list.
	(link_imm_use): Link a node to the correct list.
	(set_ssa_use_from_ptr): Set a use node to a specific value, and insert
	it in the correct list, if appropriate.
	(link_imm_use_stmt): Link a use node, and set the stmt pointer.
	(relink_imm_use): Link a use node in place of another node in a list.
	(relink_imm_use_stmt): LInk a node in place of another node, and set
	the stmt pointer.
	(end_safe_imm_use_traverse): New.  Terminate a safe immuse iterator.
	(end_safe_imm_use_p): New.  Check for the end of a safe immuse iterator.
	(first_safe_imm_use): New.  Initialize a safe immuse iterator.
	(next_safe_imm_use): New.  Proceed to next safe immuse iterator value.
	(end_readonly_imm_use_p): New.  Check for end of a fast immuse iterator.
	(first_readonly_imm_use): New.  Initialize a fast immuse iterator.
	(next_readonly_imm_use): New.  Get the next fast immuse iterator value.
	(has_zero_uses): New.  Return true if there are no uses of a var.
	(has_single_use): New.  Return true if there is only a single use of a
	variable.
	(single_imm_use): New.  Return the simgle immediate use.
	(num_imm_uses): New.  Return the number of immediate uses.
	(get_v_must_def_ops): Use is now a pointer.
	(use_operand_p, get_v_may_def_op_ptr, get_vuse_op_ptr,
	get_v_must_def_kill_ptr, get_phi_arg_def_ptr): Return the address of
	the use node.
	(get_immediate_uses, num_immediate_uses, immediate_use): Delete.
	(delink_stmt_imm_use): Delink all immuses from a stmt.
	(phi_arg_index_from_use): New.  Return a phi arg index for a use.
	* tree-flow.h (struct dataflow_d): Delete.
	(immediate_use_iterator_d): New.  Immediate use iterator struct.
	(FOR_EACH_IMM_USE_FAST): New.  Macro for read only immuse iteration.
	(FOR_EACH_IMM_USE_SAFE): New.  Macro for write-safe immuse iteration.
	(BREAK_FROM_SAFE_IMM_USE): New.  Macro for earlyu exit from write-safe
	iteration.
	(struct stmt_ann_d): Remove dataflow_t from struct.
	* tree-if-conv.c (tree_if_conversion).  Don't call free_df.
	(if_convertible_phi_p): Use FAST immuse iterator.
	(if_convertible_loop_p): Don't call compute_immediate_uses.
	(replace_phi_with_cond_modify_expr): Call update_stmt.
	* tree-into-ssa.c (mark_def_sites, ssa_mark_def_sites): Call
	update_stmt_if_modified.
	(rewrite_all_into_ssa): Initialize ssa operands.
	* tree-loop-linear.c (linear_transform_loops): Don't call free_df or
	compute_immediate_uses.
	* tree-optimize.c (execute_todo): Call verify_ssa whenever the
	ssa_property is available.
	(execute_one_pass):  Change parameters passed to execute_todo.
	* tree-outof-ssa.c (rewrite_trees): Don't call modify_stmt.
	(remove_ssa_form): Call fini_ssa_operands.
	(insert_backedge_copies): Delete call to modify_stmt.
	* tree-phinodes.c (make_phi_node): Initialize use nodes.
	(release_phi_node): Delink any use nodes before releasing.
	(resize_phi_node): Relink any use nodes.
	(remove_phi_arg_num): Delink the use node.
	(remove_phi_node): Release the ssa_name AFTER releasing the phi node.
	(remove_all_phi_nodes_for): Release phi node first.
	* tree-pretty-print.c (dump_generic_node): Print stmt address.
	* tree-sra.c (mark_all_v_defs): Call update_stmt_if_modified.
	(scalarize_use, scalarize_copy): Call update_stmt.
	* tree-ssa-alias.c (compute_may_aliases): Update all modified stmts.
	(compute_points_to_and_addr_escape): Call mark_stmt_modified.
	* tree-ssa-cpp.c (need_imm_uses_for): Delete.
	(ccp_initialize): Remove call to compute_immediate_uses.
	(substitute_and_fold, execute_fold_all_builtins): Call update_stmt.
	* tree-ssa-dom.c (tree_ssa_dominator_optimize): Update all modified
	stmts.
	(simplify_cond_and_lookup_avail_expr): Call mark_stmt_modified.
	(simplify_switch_and_lookup_avail_expr): Call mark_stmt_modified.
	(eliminate_redundant_computations): Call mark_stmt_modified.
	(cprop_operand): Call mark_stmt_modified.
	(optimize_stmt): Call update_stmt_if_modified and mark_stmt_modified.
	* tree-ssa-dse.c (fix_phi_uses, fix_stmt_v_may_defs): Delete.
	(dse_optimize_stmt): Use new immuse interface.
	(tree_ssa_dse): Remove calls to compute_immediate_uses and free_df.
	* tree-ssa-forwprop.c (need_imm_uses_for): Delete.
	(substitute_single_use_vars): Use new immuse interface.
	(tree_ssa_forward_propagate_single_use_vars): Remove calls to free_df
	and compute_immediate_uses.
	* tree-ssa-loop-im.c (single_reachable_address): Use new immuse
	interface.
	(rewrite_mem_refs): Call update_stmt.
	(determine_lsm): Remove call to compute_imm_uses and free_df.
	* tree-ssa-loop-ivcanon.c (create_canonical_iv): Call update_stmt.
	(try_unroll_loop_completely): Call update_stmt.
	* tree-ssa-loop-ivopts.c (rewrite_address_base): Call update_stmt.
	(rewrite_use_compare): Call update_stmt.
	(compute_phi_arg_on_exit): Insert each stmt before trying to process.
	(rewrite_use) : Call update_stmt.
	* tree-ssa-loop-manip.c (verify_loop_closed_ssa): Add arg to call.
	* tree-ssa-loop-unswitch.c (tree_unswitch_single_loop): Call
	update_stmt.
	* tree-ssa-operands.c (NULL_USE_OPERAND_P): Remove declaration.
	(allocate_use_optype, allocate_vuse_optype): Adjust allocation size.
	(free_uses, free_vuses, free_v_may_defs, free_v_must_defs): Delink
	use nodes.
	(initialize_vuse_operand): New.  Initialize a vuse operand.
	(initialize_v_may_def_operand): New.  Initialize a maydef operand.
	(initialize_v_must_def_operand): New.  Initialize a mustdef operand.
	(finalize_ssa_defs): Use stmt parameter.
	(correct_use_link): Ensure a use node is in the correct list, and has
	the correct stmt pointer.
	(finalize_ssa_uses, finalize_ssa_v_may_defs, finalize_ssa_vuses,
	finalize_ssa_v_must_defs): Also initialize use nodes.
	(finalize_ssa_stmt_operands): Pass extra stmt operands.
	(build_ssa_operands): Seperate parsing from final operand construction.
	(parse_ssa_operands): New.  Parse entry point for operand building.
	(swap_tree_operands): New.  Swap 2 tree operands.
	(update_stmt_operands): Ranamed from get_stmt_operands.  Always builds
	operands.
	(get_expr_operands): Call swap_tree_operands when needed.
	(copy_virtual_operands): Use initialize routines for virtual use ops.
	(create_ssa_artficial_load_stmt): Add extra stmt parameter.
	(verify_abort): New.  Issue imm_use error.
	(verify_imm_links): New Verify imm_use links for a var.
	(dump_immediate_uses_for): New.  Dump imm_uses for a var to file.
	(dump_immediate_uses): New.  Dump imm_uses for all vars to file.
	(debug_immediate_uses): New.  Dump imm_uses for all vars to stderr.
	(debug_immediate_uses_for): New.  Dump imm_uses for a var to stderr.
	* tree-ssa-operands.h (struct use_operand_ptr): Delete.
	(NULL_USE_OPERAND_P) Define.
	(use_optype_d, v_def_use_operand_type, vuse_optype_d): Add immediate
	use node.
	(struct vuse_operand_type): New struct.
	(SET_USE): Call set_ssa_use_from_ptr.
	(USE_STMT): Define.
	(PHI_ARG_INDEX_FROM_USE): Define.
	* tree-ssa-phiopt.c (replace_phi_edge_with_variable): Set the phi
	argument via SET_USE, not PHI_ARG_DEF_TREE.
	* tree-ssa-pre.c (eliminate): Call update_stmt.
	* tree-ssa-propagate.c (cfg_blocks_get): Use imm_use iterators.  Don't
	call free_df.
	* tree-ssa-sink.c (all_immediate_uses_same_place): Use imm_use iterator.
	(nearest_common_dominator_of_uses): Use imm_use iterator.
	(statement_sink_location): Use imm_use iterator and interface.
	(execute_sink_code): Don't call compute_immediate_uses or free-df.
	* tree-ssa-threadupdate.c (create_edge_and_update_destination_phis): Use
	PHI_ARG_DEF, not PHI_ARG_DEF_TREE.
	* tree-ssa.c (verify_use, verify_phi_args): Verify some imm_use info.
	(verify_ssa): Ensure no stmt is marked modify after optimization pass
	if new parameter is true.
	(init_tree_ssa): Don't initialize operand cache here.
	(delete_tree_ssa): Don't destroy operand cache here.
	(propagate_into_addr): Pass in a use pointer, return true if anything
	was changed.
	(replace_immediate_uses): Use imm_use iterator, call update_stmt.
	(check_phi_redundancy): Use imm_use iterator.
	(kill_redundant_phi_nodes): Don't call compute_immediate_uses or
	free_df.
	* tree-ssanames.c (make_ssa_name): Initialize imm_use node.
	(release_ssa_name): Delink node and all elements in its imm_use list.
	* tree-tailcall.c (adjust_return_value): Call update_stmt.
	* tree-vect-analyze.c (vect_stmt_relevant_p): Use imm_use iterator.
	* tree-vectorizer.c (need_imm_uses_for): Delete.
	(vectorize_loops): Dont call compute_immediate_uses or free_df.
	* tree.h (struct ssa_imm_use_d): Define.
	(SSA_NAME_IMM_USE_NODE): Define.
	(struct tree_ssa_name): Add imm_use node.
	(PHI_DF): Delete.
	(PHI_ARG_IMM_USE_NODE): Define.
	(struct phi_arg_d): Add imm_use node.
	(struct tree_phi_node): Remove struct dataflow_d element.
	(TDF_STMTADDR): Define.


git-svn-id: https://gcc.gnu.org/svn/gcc/trunk@97648 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 92 insertions, 68 deletions

diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c
index a9564b86c4a..e23e665d42a 100644
--- a/gcc/tree-ssa.c
+++ b/gcc/tree-ssa.c
@@ -215,13 +215,19 @@ err:
      that are defined before STMT in basic block BB.  */
 
 static bool
-verify_use (basic_block bb, basic_block def_bb, tree ssa_name,
+verify_use (basic_block bb, basic_block def_bb, use_operand_p use_p,
 	    tree stmt, bool check_abnormal, bool is_virtual,
 	    bitmap names_defined_in_bb)
 {
   bool err = false;
+  tree ssa_name = USE_FROM_PTR (use_p);
 
   err = verify_ssa_name (ssa_name, is_virtual);
+
+  if (!TREE_VISITED (ssa_name))
+    if (verify_imm_links (stderr, ssa_name))
+      err = true;
+
   TREE_VISITED (ssa_name) = 1;
 
   if (IS_EMPTY_STMT (SSA_NAME_DEF_STMT (ssa_name))
@@ -254,6 +260,27 @@ verify_use (basic_block bb, basic_block def_bb, tree ssa_name,
       err = true;
     }
 
+  /* Make sure the use is in an appropriate list by checking the previous 
+     element to make sure its the same.  */
+  if (use_p->prev == NULL)
+    {
+      error ("No immediate_use list");
+      err = true;
+    }
+  else
+    {
+      tree listvar ;
+      if (use_p->prev->use == NULL)
+	listvar = use_p->prev->stmt;
+      else
+	listvar = USE_FROM_PTR (use_p->prev);
+      if (listvar != ssa_name)
+        {
+	  error ("Wrong immediate use list");
+	  err = true;
+	}
+    }
+
   if (err)
     {
       fprintf (stderr, "for SSA_NAME: ");
@@ -289,7 +316,9 @@ verify_phi_args (tree phi, basic_block bb, basic_block *definition_block)
 
   for (i = 0; i < phi_num_args; i++)
     {
-      tree op = PHI_ARG_DEF (phi, i);
+      use_operand_p op_p = PHI_ARG_DEF_PTR (phi, i);
+      tree op = USE_FROM_PTR (op_p);
+
 
       e = EDGE_PRED (bb, i);
 
@@ -309,7 +338,7 @@ verify_phi_args (tree phi, basic_block bb, basic_block *definition_block)
 	}
 
       if (TREE_CODE (op) == SSA_NAME)
-	err = verify_use (e->src, definition_block[SSA_NAME_VERSION (op)], op,
+	err = verify_use (e->src, definition_block[SSA_NAME_VERSION (op)], op_p,
 			  phi, e->flags & EDGE_ABNORMAL,
 			  !is_gimple_reg (PHI_RESULT (phi)),
 			  NULL);
@@ -601,7 +630,7 @@ verify_alias_info (void)
    TODO: verify the variable annotations.  */
 
 void
-verify_ssa (void)
+verify_ssa (bool check_modified_stmt)
 {
   size_t i;
   basic_block bb;
@@ -668,8 +697,16 @@ verify_ssa (void)
       for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
 	{
 	  tree stmt = bsi_stmt (bsi);
+	  use_operand_p use_p;
+
+	  if (check_modified_stmt && stmt_modified_p (stmt))
+	    {
+	      error ("Stmt (0x%x) marked modified after optimization pass : ",
+		     (unsigned long)stmt);
+	      print_generic_stmt (stderr, stmt, TDF_VOPS);
+	      goto err;
+	    }
 
-	      get_stmt_operands (stmt);
 
 	      if (stmt_ann (stmt)->makes_aliased_stores 
 		  && NUM_V_MAY_DEFS (STMT_V_MAY_DEF_OPS (stmt)) == 0)
@@ -679,10 +716,11 @@ verify_ssa (void)
 		  goto err;
 		}
 
-	  FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_ALL_USES | SSA_OP_ALL_KILLS)
+	  FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_ALL_USES | SSA_OP_ALL_KILLS)
 	    {
+	      op = USE_FROM_PTR (use_p);
 	      if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
-			      op, stmt, false, !is_gimple_reg (op),
+			      use_p, stmt, false, !is_gimple_reg (op),
 			      names_defined_in_bb))
 		goto err;
 	    }
@@ -724,7 +762,6 @@ init_tree_ssa (void)
   VARRAY_TREE_INIT (referenced_vars, 20, "referenced_vars");
   call_clobbered_vars = BITMAP_ALLOC (NULL);
   addressable_vars = BITMAP_ALLOC (NULL);
-  init_ssa_operands ();
   init_ssanames ();
   init_phinodes ();
   global_var = NULL_TREE;
@@ -765,7 +802,6 @@ delete_tree_ssa (void)
 
   fini_ssanames ();
   fini_phinodes ();
-  fini_ssa_operands ();
 
   global_var = NULL_TREE;
   BITMAP_FREE (call_clobbered_vars);
@@ -994,10 +1030,10 @@ walk_use_def_chains (tree var, walk_use_def_chains_fn fn, void *data,
 
 
 /* Replaces VAR with REPL in memory reference expression *X in
-   statement STMT.  */
+   statement STMT at use location USE_P.  Return TRUE if Anything was done.  */
 
-static void
-propagate_into_addr (tree stmt, tree var, tree *x, tree repl)
+static bool
+propagate_into_addr (tree stmt, use_operand_p use_p, tree *x, tree repl)
 {
   tree new_var, ass_stmt, addr_var;
   basic_block bb;
@@ -1005,7 +1041,7 @@ propagate_into_addr (tree stmt, tree var, tree *x, tree repl)
 
   /* There is nothing special to handle in the other cases.  */
   if (TREE_CODE (repl) != ADDR_EXPR)
-    return;
+    return false;
   addr_var = TREE_OPERAND (repl, 0);
 
   while (handled_component_p (*x)
@@ -1013,22 +1049,24 @@ propagate_into_addr (tree stmt, tree var, tree *x, tree repl)
 	 || TREE_CODE (*x) == IMAGPART_EXPR)
     x = &TREE_OPERAND (*x, 0);
 
+  /* Heres a hack but since KRPhinodes is going away soon, Im not going to 
+     sweat it.  */
   if (TREE_CODE (*x) != INDIRECT_REF
-      || TREE_OPERAND (*x, 0) != var)
-    return;
+      || &(TREE_OPERAND (*x, 0)) != use_p->use)  /* HACK ALERT. */
+    return false;
 
   if (TREE_TYPE (*x) == TREE_TYPE (addr_var))
     {
       *x = addr_var;
       mark_new_vars_to_rename (stmt, vars_to_rename);
-      return;
+      return true;
     }
 
 
   /* Frontends sometimes produce expressions like *&a instead of a[0].
      Create a temporary variable to handle this case.  */
   ass_stmt = build2 (MODIFY_EXPR, void_type_node, NULL_TREE, repl);
-  new_var = duplicate_ssa_name (var, ass_stmt);
+  new_var = duplicate_ssa_name (USE_FROM_PTR (use_p), ass_stmt);
   TREE_OPERAND (*x, 0) = new_var;
   TREE_OPERAND (ass_stmt, 0) = new_var;
 
@@ -1038,6 +1076,7 @@ propagate_into_addr (tree stmt, tree var, tree *x, tree repl)
   bsi_insert_after (&bsi, ass_stmt, BSI_NEW_STMT);
 
   mark_new_vars_to_rename (stmt, vars_to_rename);
+  return true;
 }
 
 /* Replaces immediate uses of VAR by REPL.  */
@@ -1045,58 +1084,53 @@ propagate_into_addr (tree stmt, tree var, tree *x, tree repl)
 static void
 replace_immediate_uses (tree var, tree repl)
 {
-  int i, j, n;
-  dataflow_t df;
   tree stmt;
   bool mark_new_vars;
-  ssa_op_iter iter;
-  use_operand_p use_p;
+  use_operand_p imm_use;
+  imm_use_iterator imm_iter;
 
-  df = get_immediate_uses (SSA_NAME_DEF_STMT (var));
-  n = num_immediate_uses (df);
-
-  for (i = 0; i < n; i++)
+  FOR_EACH_IMM_USE_SAFE (imm_use, imm_iter, var)
     {
-      stmt = immediate_use (df, i);
+      stmt = USE_STMT (imm_use);
 
       if (TREE_CODE (stmt) == PHI_NODE)
 	{
-	  for (j = 0; j < PHI_NUM_ARGS (stmt); j++)
-	    if (PHI_ARG_DEF (stmt, j) == var)
-	      {
-		SET_PHI_ARG_DEF (stmt, j, repl);
-		if (TREE_CODE (repl) == SSA_NAME
-		    && PHI_ARG_EDGE (stmt, j)->flags & EDGE_ABNORMAL)
-		  SSA_NAME_OCCURS_IN_ABNORMAL_PHI (repl) = 1;
-	      }
-
+	  int index = PHI_ARG_INDEX_FROM_USE (imm_use);
+#ifdef ENABLE_CHECKING
+	  gcc_assert (&(PHI_ARG_IMM_USE_NODE (stmt, index)) == imm_use);
+#endif
+	    SET_USE (imm_use, repl);
+	  if (TREE_CODE (repl) == SSA_NAME
+	      && PHI_ARG_EDGE (stmt, index)->flags & EDGE_ABNORMAL)
+	    SSA_NAME_OCCURS_IN_ABNORMAL_PHI (repl) = 1;
 	  continue;
 	}
 
-      get_stmt_operands (stmt);
+      gcc_assert (!stmt_modified_p (stmt));
+
       mark_new_vars = false;
       if (is_gimple_reg (SSA_NAME_VAR (var)))
 	{
+	  bool propagated = false;
 	  if (TREE_CODE (stmt) == MODIFY_EXPR)
 	    {
-	      propagate_into_addr (stmt, var, &TREE_OPERAND (stmt, 0), repl);
-	      propagate_into_addr (stmt, var, &TREE_OPERAND (stmt, 1), repl);
+	      if (TREE_CODE (repl) == ADDR_EXPR)
+		{
+		  propagated =
+		    propagate_into_addr (stmt, imm_use, &TREE_OPERAND (stmt, 0),
+					 repl);
+		  if (!propagated)
+		    propagated =
+		      propagate_into_addr (stmt, imm_use,
+					   &TREE_OPERAND (stmt, 1), repl);
+		}
 	    }
-
-	  FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
-	    if (USE_FROM_PTR (use_p) == var)
-	      {
-		propagate_value (use_p, repl);
-		mark_new_vars = POINTER_TYPE_P (TREE_TYPE (repl));
-	      }
+	  if (!propagated)
+	    propagate_value (imm_use, repl);
+	  mark_new_vars = POINTER_TYPE_P (TREE_TYPE (repl));
 	}
       else
-	{
-	  FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, 
-				    SSA_OP_VIRTUAL_USES | SSA_OP_VIRTUAL_KILLS)
-	    if (USE_FROM_PTR (use_p) == var)
-	      propagate_value (use_p, repl);
-	}
+        propagate_value (imm_use, repl);
 
       /* FIXME.  If REPL is a constant, we need to fold STMT.
 	 However, fold_stmt wants a pointer to the statement, because
@@ -1119,7 +1153,6 @@ replace_immediate_uses (tree var, tree repl)
 	    {
 	      block_stmt_iterator si = bsi_for_stmt (stmt);
 	      mark_new_vars_to_rename (tmp, vars_to_rename);
-	      redirect_immediate_uses (stmt, tmp);
 	      bsi_replace (&si, tmp, true);
 	      stmt = bsi_stmt (si);
 	    }
@@ -1133,8 +1166,9 @@ replace_immediate_uses (tree var, tree repl)
       if (mark_new_vars)
 	mark_new_vars_to_rename (stmt, vars_to_rename);
       else
-	modify_stmt (stmt);
+	update_stmt (stmt);
     }
+
 }
 
 /* Gets the value VAR is equivalent to according to EQ_TO.  */
@@ -1174,8 +1208,9 @@ static void
 check_phi_redundancy (tree phi, tree *eq_to)
 {
   tree val = NULL_TREE, def, res = PHI_RESULT (phi), stmt;
-  unsigned i, ver = SSA_NAME_VERSION (res), n;
-  dataflow_t df;
+  unsigned i, ver = SSA_NAME_VERSION (res);
+  imm_use_iterator imm_iter;
+  use_operand_p use_p;
 
   /* It is unlikely that such large phi node would be redundant.  */
   if (PHI_NUM_ARGS (phi) > 16)
@@ -1211,13 +1246,9 @@ check_phi_redundancy (tree phi, tree *eq_to)
 
   eq_to[ver] = val;
 
-  df = get_immediate_uses (SSA_NAME_DEF_STMT (res));
-  n = num_immediate_uses (df);
-
-  for (i = 0; i < n; i++)
+  FOR_EACH_IMM_USE_FAST (use_p, imm_iter, res)
     {
-      stmt = immediate_use (df, i);
-
+      stmt = USE_STMT (use_p);
       if (TREE_CODE (stmt) == PHI_NODE)
 	check_phi_redundancy (stmt, eq_to);
     }
@@ -1257,12 +1288,6 @@ kill_redundant_phi_nodes (void)
      it safe).  */
   eq_to = xcalloc (num_ssa_names, sizeof (tree));
 
-  /* We have had cases where computing immediate uses takes a
-     significant amount of compile time.  If we run into such
-     problems here, we may want to only compute immediate uses for
-     a subset of all the SSA_NAMEs instead of computing it for
-     all of the SSA_NAMEs.  */
-  compute_immediate_uses (TDFA_USE_OPS | TDFA_USE_VOPS, NULL);
   old_num_ssa_names = num_ssa_names;
 
   FOR_EACH_BB (bb)
@@ -1296,7 +1321,6 @@ kill_redundant_phi_nodes (void)
 	}
     }
 
-  free_df ();
   free (eq_to);
 }