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: svn+ssh://gcc.gnu.org/svn/gcc/trunk@97648 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 377 insertions, 70 deletions

diff --git a/gcc/tree-flow-inline.h b/gcc/tree-flow-inline.h
index 4d6f5cb1485..d43812ef0fc 100644
--- a/gcc/tree-flow-inline.h
+++ b/gcc/tree-flow-inline.h
@@ -141,9 +141,13 @@ noreturn_call_p (tree t)
 
 /* Mark statement T as modified.  */
 static inline void
-modify_stmt (tree t)
+mark_stmt_modified (tree t)
 {
-  stmt_ann_t ann = stmt_ann (t);
+  stmt_ann_t ann;
+  if (TREE_CODE (t) == PHI_NODE)
+    return;
+
+  ann = stmt_ann (t);
   if (ann == NULL)
     ann = create_stmt_ann (t);
   else if (noreturn_call_p (t))
@@ -151,14 +155,42 @@ modify_stmt (tree t)
   ann->modified = 1;
 }
 
-/* Mark statement T as unmodified.  */
+/* Mark statement T as modified, and update it.  */
 static inline void
-unmodify_stmt (tree t)
+update_stmt (tree t)
 {
-  stmt_ann_t ann = stmt_ann (t);
-  if (ann == NULL)
-    ann = create_stmt_ann (t);
-  ann->modified = 0;
+  if (TREE_CODE (t) == PHI_NODE)
+    return;
+  mark_stmt_modified (t);
+  update_stmt_operands (t);
+}
+
+static inline void
+update_stmt_if_modified (tree t)
+{
+  if (stmt_modified_p (t))
+    update_stmt_operands (t);
+}
+
+static inline void 
+get_stmt_operands (tree stmt ATTRIBUTE_UNUSED)
+{
+#ifdef ENABLE_CHECKING
+  stmt_ann_t ann;
+                                                                                
+  /* The optimizers cannot handle statements that are nothing but a
+     _DECL.  This indicates a bug in the gimplifier.  */
+  gcc_assert (!SSA_VAR_P (stmt));
+                                                                                
+  /* Ignore error statements.  */
+  if (TREE_CODE (stmt) == ERROR_MARK)
+    return;
+                                                                                
+  ann = get_stmt_ann (stmt);
+  gcc_assert (!ann->modified);
+
+  return;
+#endif
 }
 
 /* Return true if T is marked as modified, false otherwise.  */
@@ -168,11 +200,286 @@ stmt_modified_p (tree t)
   stmt_ann_t ann = stmt_ann (t);
 
   /* Note that if the statement doesn't yet have an annotation, we consider it
-     modified.  This will force the next call to get_stmt_operands to scan the
-     statement.  */
+     modified.  This will force the next call to update_stmt_operands to scan 
+     the statement.  */
   return ann ? ann->modified : true;
 }
 
+/* Delink an immediate_uses node from its chain.  */
+static inline void
+delink_imm_use (ssa_imm_use_t *linknode)
+{
+  /* Return if this node is not in a list.  */
+  if (linknode->prev == NULL)
+    return;
+
+  linknode->prev->next = linknode->next;
+  linknode->next->prev = linknode->prev;
+  linknode->prev = NULL;
+  linknode->next = NULL;
+}
+
+/* Link ssa_imm_use node LINKNODE into the chain for LIST.  */
+static inline void
+link_imm_use_to_list (ssa_imm_use_t *linknode, ssa_imm_use_t *list)
+{
+  /* Link the new node at the head of the list.  If we are in the process of 
+     traversing the list, we wont visit any new nodes added to it.  */
+  linknode->prev = list;
+  linknode->next = list->next;
+  list->next->prev = linknode;
+  list->next = linknode;
+}
+
+/* Link ssa_imm_use node LINKNODE into the chain for DEF.  */
+static inline void
+link_imm_use (ssa_imm_use_t *linknode, tree def)
+{
+  ssa_imm_use_t *root;
+
+  if (!def || TREE_CODE (def) != SSA_NAME)
+    linknode->prev = NULL;
+  else
+    {
+      root = &(SSA_NAME_IMM_USE_NODE (def));
+#ifdef ENABLE_CHECKING
+      if (linknode->use)
+        gcc_assert (*(linknode->use) == def);
+#endif
+      link_imm_use_to_list (linknode, root);
+    }
+}
+
+/* Set the value of a use pointed by USE to VAL.  */
+static inline void
+set_ssa_use_from_ptr (use_operand_p use, tree val)
+{
+  delink_imm_use (use);
+  *(use->use) = val;
+  link_imm_use (use, val);
+}
+
+/* Link ssa_imm_use node LINKNODE into the chain for DEF, with use occuring 
+   in STMT.  */
+static inline void
+link_imm_use_stmt (ssa_imm_use_t *linknode, tree def, tree stmt)
+{
+  if (stmt)
+    link_imm_use (linknode, def);
+  else
+    link_imm_use (linknode, NULL);
+  linknode->stmt = stmt;
+}
+
+/* Relink a new node in place of an old node in the list.  */
+static inline void
+relink_imm_use (ssa_imm_use_t *node, ssa_imm_use_t *old)
+{
+#ifdef ENABLE_CHECKING
+  /* The node one had better be in the same list.  */
+  if (*(old->use) != *(node->use))
+    abort ();
+#endif
+  node->prev = old->prev;
+  node->next = old->next;
+  if (old->prev)
+    {
+      old->prev->next = node;
+      old->next->prev = node;
+      /* Remove the old node from the list.  */
+      old->prev = NULL;
+    }
+
+}
+
+/* Relink ssa_imm_use node LINKNODE into the chain for OLD, with use occuring 
+   in STMT.  */
+static inline void
+relink_imm_use_stmt (ssa_imm_use_t *linknode, ssa_imm_use_t *old, tree stmt)
+{
+  if (stmt)
+    relink_imm_use (linknode, old);
+  else
+    link_imm_use (linknode, NULL);
+  linknode->stmt = stmt;
+}
+
+/* Finished the traverse of an immediate use list IMM by removing it from 
+   the list.  */
+static inline void
+end_safe_imm_use_traverse (imm_use_iterator *imm)
+{
+ delink_imm_use (&(imm->iter_node));
+}
+
+/* Return true if IMM is at the end of the list.  */
+static inline bool
+end_safe_imm_use_p (imm_use_iterator *imm)
+{
+  return (imm->imm_use == imm->end_p);
+}
+
+/* Initialize iterator IMM to process the list for VAR.  */
+static inline use_operand_p
+first_safe_imm_use (imm_use_iterator *imm, tree var)
+{
+  /* Set up and link the iterator node into the linked list for VAR.  */
+  imm->iter_node.use = NULL;
+  imm->iter_node.stmt = NULL_TREE;
+  imm->end_p = &(SSA_NAME_IMM_USE_NODE (var));
+  /* Check if there are 0 elements.  */
+  if (imm->end_p->next == imm->end_p)
+    {
+      imm->imm_use = imm->end_p;
+      return NULL_USE_OPERAND_P;
+    }
+
+  link_imm_use (&(imm->iter_node), var);
+  imm->imm_use = imm->iter_node.next;
+  return imm->imm_use;
+}
+
+/* Bump IMM to then next use in the list.  */
+static inline use_operand_p
+next_safe_imm_use (imm_use_iterator *imm)
+{
+  ssa_imm_use_t *ptr;
+  use_operand_p old;
+
+  old = imm->imm_use;
+  /* If the next node following the iter_node is still the one refered to by
+     imm_use, then the list hasnt changed, go to the next node.  */
+  if (imm->iter_node.next == imm->imm_use)
+    {
+      ptr = &(imm->iter_node);
+      /* Remove iternode fromn the list.  */
+      delink_imm_use (ptr);
+      imm->imm_use = imm->imm_use->next;
+      if (! end_safe_imm_use_p (imm))
+	{
+	  /* This isnt the end, link iternode before the next use.  */
+	  ptr->prev = imm->imm_use->prev;
+	  ptr->next = imm->imm_use;
+	  imm->imm_use->prev->next = ptr;
+	  imm->imm_use->prev = ptr;
+	}
+      else
+	return old;
+    }
+  else
+    {
+      /* If the 'next' value after the iterator isn't the same as it was, then
+	 a node has been deleted, so we sinply proceed to the node following 
+	 where the iterator is in the list.  */
+      imm->imm_use = imm->iter_node.next;
+      if (end_safe_imm_use_p (imm))
+        {
+	  end_safe_imm_use_traverse (imm);
+	  return old;
+	}
+    }
+
+  return imm->imm_use;
+}
+
+/* Return true is IMM has reached the end of the immeidate use list.  */
+static inline bool
+end_readonly_imm_use_p (imm_use_iterator *imm)
+{
+  return (imm->imm_use == imm->end_p);
+}
+
+/* Initialize iterator IMM to process the list for VAR.  */
+static inline use_operand_p
+first_readonly_imm_use (imm_use_iterator *imm, tree var)
+{
+  gcc_assert (TREE_CODE (var) == SSA_NAME);
+
+  imm->end_p = &(SSA_NAME_IMM_USE_NODE (var));
+  imm->imm_use = imm->end_p->next;
+#ifdef ENABLE_CHECKING
+  imm->iter_node.next = imm->imm_use->next;
+#endif
+  if (end_readonly_imm_use_p (imm))
+    return NULL_USE_OPERAND_P;
+  return imm->imm_use;
+}
+
+/* Bump IMM to then next use in the list.  */
+static inline use_operand_p
+next_readonly_imm_use (imm_use_iterator *imm)
+{
+  use_operand_p old = imm->imm_use;
+
+#ifdef ENABLE_CHECKING
+  /* If this assertion fails, it indicates the 'next' pointer has changed 
+     since we the last bump.  This indicates that the list is being modified
+     via stmt changes, or SET_USE, or somesuch thing, and you need to be
+     using the SAFE version of the iterator.  */
+  gcc_assert (imm->iter_node.next == old->next);
+  imm->iter_node.next = old->next->next;
+#endif
+
+  imm->imm_use = old->next;
+  if (end_readonly_imm_use_p (imm))
+    return old;
+  return imm->imm_use;
+}
+
+/* Return true if VAR has no uses.  */
+static inline bool
+has_zero_uses (tree var)
+{
+  ssa_imm_use_t *ptr;
+  ptr = &(SSA_NAME_IMM_USE_NODE (var));
+  /* A single use means there is no items in the list.  */
+  return (ptr == ptr->next);
+}
+
+/* Return true if VAR has a single use.  */
+static inline bool
+has_single_use (tree var)
+{
+  ssa_imm_use_t *ptr;
+  ptr = &(SSA_NAME_IMM_USE_NODE (var));
+  /* A single use means there is one item in the list.  */
+  return (ptr != ptr->next && ptr == ptr->next->next);
+}
+
+/* If VAR has only a single immediate use, return true, and set USE_P and STMT
+   to the use pointer and stmt of occurence.  */
+static inline bool
+single_imm_use (tree var, use_operand_p *use_p, tree *stmt)
+{
+  ssa_imm_use_t *ptr;
+
+  ptr = &(SSA_NAME_IMM_USE_NODE (var));
+  if (ptr != ptr->next && ptr == ptr->next->next)
+    {
+      *use_p = ptr->next;
+      *stmt = ptr->next->stmt;
+      return true;
+    }
+  *use_p = NULL_USE_OPERAND_P;
+  *stmt = NULL_TREE;
+  return false;
+}
+
+/* Return the number of immediate uses of VAR.  */
+static inline unsigned int
+num_imm_uses (tree var)
+{
+  ssa_imm_use_t *ptr, *start;
+  unsigned int num;
+
+  start = &(SSA_NAME_IMM_USE_NODE (var));
+  num = 0;
+  for (ptr = start->next; ptr != start; ptr = ptr->next)
+     num++;
+
+  return num;
+}
+
 /* Return the definitions present in ANN, a statement annotation.
    Return NULL if this annotation contains no definitions.  */
 static inline def_optype
@@ -218,7 +525,7 @@ get_v_must_def_ops (stmt_ann_t ann)
 static inline tree
 get_use_from_ptr (use_operand_p use)
 { 
-  return *(use.use);
+  return *(use->use);
 } 
 
 /* Return the tree pointer to by DEF.  */
@@ -233,7 +540,7 @@ static inline use_operand_p
 get_use_op_ptr (use_optype uses, unsigned int index)
 {
   gcc_assert (index < uses->num_uses);
-  return uses->uses[index];
+  return &(uses->uses[index]);
 }
 
 /* Return a def_operand_p pointer for element INDEX of DEFS.  */
@@ -244,7 +551,6 @@ get_def_op_ptr (def_optype defs, unsigned int index)
   return defs->defs[index];
 }
 
-
 /* Return the def_operand_p that is the V_MAY_DEF_RESULT for the V_MAY_DEF
    at INDEX in the V_MAY_DEFS array.  */
 static inline def_operand_p
@@ -261,20 +567,16 @@ get_v_may_def_result_ptr(v_may_def_optype v_may_defs, unsigned int index)
 static inline use_operand_p
 get_v_may_def_op_ptr(v_may_def_optype v_may_defs, unsigned int index)
 {
-  use_operand_p op;
   gcc_assert (index < v_may_defs->num_v_may_defs);
-  op.use = &(v_may_defs->v_may_defs[index].use);
-  return op;
+  return &(v_may_defs->v_may_defs[index].imm_use);
 }
 
 /* Return a use_operand_p that is at INDEX in the VUSES array.  */
 static inline use_operand_p
 get_vuse_op_ptr(vuse_optype vuses, unsigned int index)
 {
-  use_operand_p op;
   gcc_assert (index < vuses->num_vuses);
-  op.use = &(vuses->vuses[index]);
-  return op;
+  return &(vuses->vuses[index].imm_use);
 }
 
 /* Return a def_operand_p that is the V_MUST_DEF_RESULT for the
@@ -293,10 +595,8 @@ get_v_must_def_result_ptr (v_must_def_optype v_must_defs, unsigned int index)
 static inline use_operand_p
 get_v_must_def_kill_ptr (v_must_def_optype v_must_defs, unsigned int index)
 {
-  use_operand_p op;
   gcc_assert (index < v_must_defs->num_v_must_defs);
-  op.use = &(v_must_defs->v_must_defs[index].use);
-  return op;
+  return &(v_must_defs->v_must_defs[index].imm_use);
 }
 
 /* Return a def_operand_p pointer for the result of PHI.  */
@@ -312,64 +612,40 @@ get_phi_result_ptr (tree phi)
 static inline use_operand_p
 get_phi_arg_def_ptr (tree phi, int i)
 {
-  use_operand_p op;
-  op.use = &(PHI_ARG_DEF_TREE (phi, i));
-  return op;
-}
- 
-/* Return the bitmap of addresses taken by STMT, or NULL if it takes
-   no addresses.  */
-static inline bitmap
-addresses_taken (tree stmt)
-{
-  stmt_ann_t ann = stmt_ann (stmt);
-  return ann ? ann->addresses_taken : NULL;
+  return &(PHI_ARG_IMM_USE_NODE (phi,i));
 }
 
-/* Return the immediate uses of STMT, or NULL if this information is
-   not computed.  */
-static dataflow_t
-get_immediate_uses (tree stmt)
+/* Delink all immediate_use information for STMT.  */
+static inline void
+delink_stmt_imm_use (tree stmt)
 {
-  stmt_ann_t ann;
+   unsigned int x;
+   use_optype uses = STMT_USE_OPS (stmt);
+   vuse_optype vuses = STMT_VUSE_OPS (stmt);
+   v_may_def_optype v_may_defs = STMT_V_MAY_DEF_OPS (stmt);
+   v_must_def_optype v_must_defs = STMT_V_MUST_DEF_OPS (stmt);
 
-  if (TREE_CODE (stmt) == PHI_NODE)
-    return PHI_DF (stmt);
+   for (x = 0; x < NUM_USES (uses); x++)
+     delink_imm_use (&(uses->uses[x]));
 
-  ann = stmt_ann (stmt);
-  return ann ? ann->df : NULL;
-}
+   for (x = 0; x < NUM_VUSES (vuses); x++)
+     delink_imm_use (&(vuses->vuses[x].imm_use));
 
-/* Return the number of immediate uses present in the dataflow
-   information at DF.  */
-static inline int
-num_immediate_uses (dataflow_t df)
-{
-  varray_type imm;
+   for (x = 0; x < NUM_V_MAY_DEFS (v_may_defs); x++)
+     delink_imm_use (&(v_may_defs->v_may_defs[x].imm_use));
 
-  if (!df)
-    return 0;
-
-  imm = df->immediate_uses;
-  if (!imm)
-    return df->uses[1] ? 2 : 1;
-
-  return VARRAY_ACTIVE_SIZE (imm) + 2;
+   for (x = 0; x < NUM_V_MUST_DEFS (v_must_defs); x++)
+     delink_imm_use (&(v_must_defs->v_must_defs[x].imm_use));
 }
 
-/* Return the tree that is at NUM in the immediate use DF array.  */
-static inline tree
-immediate_use (dataflow_t df, int num)
-{
-  if (!df)
-    return NULL_TREE;
 
-#ifdef ENABLE_CHECKING
-  gcc_assert (num < num_immediate_uses (df));
-#endif
-  if (num < 2)
-    return df->uses[num];
-  return VARRAY_TREE (df->immediate_uses, num - 2);
+/* Return the bitmap of addresses taken by STMT, or NULL if it takes
+   no addresses.  */
+static inline bitmap
+addresses_taken (tree stmt)
+{
+  stmt_ann_t ann = stmt_ann (stmt);
+  return ann ? ann->addresses_taken : NULL;
 }
 
 /* Return the basic_block annotation for BB.  */
@@ -399,6 +675,37 @@ set_phi_nodes (basic_block bb, tree l)
     set_bb_for_stmt (phi, bb);
 }
 
+/* Return the phi argument which contains the specified use.  */
+
+static inline int
+phi_arg_index_from_use (use_operand_p use)
+{
+  struct phi_arg_d *element, *root;
+  int index;
+  tree phi;
+
+  /* Since the use is the first thing in a PHI arguemnt element, we can
+     calculate its index based on casting it to an argument, and performing
+     pointer arithmetic.  */
+
+  phi = USE_STMT (use);
+  gcc_assert (TREE_CODE (phi) == PHI_NODE);
+
+  element = (struct phi_arg_d *)use;
+  root = &(PHI_ARG_ELT (phi, 0));
+  index = element - root;
+
+#ifdef ENABLE_CHECKING
+  /* Make sure the calculation doesn't have any leftover bytes.  If it does, 
+     then imm_use is liekly not the first element in phi_arg_d.  */
+  gcc_assert (
+	  (((char *)element - (char *)root) % sizeof (struct phi_arg_d)) == 0);
+  gcc_assert (index >= 0 && index < PHI_ARG_CAPACITY (phi));
+#endif
+ 
+ return index;
+}
+
 /* Mark VAR as used, so that it'll be preserved during rtl expansion.  */
 
 static inline void