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

	* lambda-code.c (gcc_loop_to_lambda_loop,
	lambda_loopnest_to_gcc_loopnest, phi_loop_edge_uses_def,
	stmt_is_bumper_for_loop, perfect_nest_p, replace_uses_of_x_with_y): Use
	generic operand interface.
	* tree-data-ref.c (find_data_references_in_loop): Use generic interface.
	* tree-dfa.c (collect_dfa_stats_r, mark_new_vars_to_rename): Use
	generic operand interface.
	* tree-flow-inline.h (delink_imm_use, link_imm_use_to_list,
	link_imm_use, link_imm_use_stmt, relink_imm_use, relink_imm_use_stmt,
	next_safe_imm_use, has_zero_uses, has_single_use, single_imm_use,
	num_imm_uses): Use ssa_use_operand_t.
	(get_def_ops, get_use_ops, get_v_may_def_ops, get_vuse_ops,
	get_v_must_def_ops): Delete.
	(get_def_from_ptr, get_phi_result_ptr): Get def directly now.
	(get_use_op_ptr, get_def_op_ptr, get_v_may_def_result_ptr,
	get_v_may_def_op_ptr, get_vuse_op_ptr, get_v_must_def_result_ptr,
	get_v_must_def_kill_ptr): Delete.
	(delink_stmt_imm_use): Move and use new operand interface.
	(op_iter_next_use, op_iter_next_def, op_iter_next_tree, op_iter_init,
	op_iter_next_tree): Use new operand implementation.
	(clear_and_done_ssa_iter): New.  Initialize a blank operand iterator.
	(op_iter_init_use, op_iter_init_def, op_iter_init_tree): Add iterator
	type check.
	(op_iter_next_mustdef, op_iter_next_maydef,
	op_iter_next_must_and_may_def): Delete. Replace with...
	(op_iter_next_maymustdef): New.  Combine must and may next operations.
	(op_iter_init_maydef, op_iter_init_mustdef,
	op_iter_init_must_and_may_def): Use new interface.
	(single_ssa_tree_operand ): New.  Process single operands only as trees.
	(single_ssa_use_operand): New.  Process single operands only as uses.
	(single_ssa_def_operand): New.  Process single operands only as defs.
	(zero_ssa_operands): New.  Return TRUE if there are zero operands of the
	specified types.
	(num_ssa_operands): New.  Count the number of specified operands.
	(compare_ssa_operands_equal): New.  Compare two statements' operands.
	(single_phi_def): New.  Return true if PHI has one def of the specified
	operand type.
	(op_iter_init_phiuse): New.  Initialize the iterator for PHI arguments.
	(op_iter_init_phidef): New.  Initialize the iterator for the PHI def.
	* tree-flow.h (struct immediate_use_iterator_d): Use ssa_use_operand_t.
	(struct stmt_ann_d): Operands field no longer require GTY().
	(vn_compute, vn_lookup_or_add, vn_add, vn_lookup): Change prototype.
	* tree-into-ssa.c (mark_def_sites): Use SSA_OP_VMUSTKILL.
	* tree-outof-ssa.c (check_replaceable, find_replaceable_in_bb,
	dump_replaceable_exprs, rewrite_trees): Use generic interface.
	* tree-phinodes.c (make_phi_node, release_phi_node, resize_phi_node):
	Use use_operand_p instead of ssa_imm_use_t *.
	* tree-pretty-print.c (dump_vops): check if operands are active before
	dumping virtual operands.
	* tree-sra.c (sra_walk_function): Use ZERO_SSA_OPERANDS.
	* tree-ssa-ccp.c (likely_value): Use ZERO_SSA_OPERANDS.
	(ccp_fold): Use new interface.
	(ccp_visit_stmt): Remove unused variables and code.
	(convert_to_gimple_builtin): Insert statements before calling
	mark_new_vars_to_rename.
	* tree-ssa-copy.c (stmt_may_generate_copy): Use ZERO_SSA_OPERANDS.
	(copy_prop_visit_cond_stmt): Use generic interface.
	* tree-ssa-dom.c (struct expr_hash_elt): Use stmt pointer, not the
	annotation in table.
	(thread_across_edge): Use generic interface.
	(initialize_hash_element): Initialzie with stmt, not annotation.
	(eliminate_redundant_computations): Use generic interface.
	(record_equivalences_from_stmt): Pass stmt, not annotation.
	(avail_expr_hash, real_avail_expr_hash, avail_expr_eq): Use generic
	interface.
	* tree-ssa-dse.c (dse_optimize_stmt): Use ZERO_SSA_OPERANDS.
	* tree-ssa-loop-ivopts.c (find_invariants_stmt,
	find_interesting_uses_stmt, protect_loop_closed_ssa_form_use): Use
	generic operand interface.
	* tree-ssa-loop-niter.c (chain_of_csts_start, get_val_for): Use generic
	interface.
	* tree-ssa-loop-unswitch.c (tree_may_unswitch_on): Use Generic operand
	Interface.
	* tree-ssa-operands.c (struct opbuild_list_d): New.  Operand build type.
	(build_defs, build_uses, build_v_may_defs, build_vuses,
	build_v_must_defs): Change type to struct opbuild_list_d.
	(ops_active): New.  Operands active boolean.
	(operand_memory, operand_memory_index): New.  Operand memory managers.
	(allocate_def_optype, allocate_use_optype, allocate_v_may_def_optype,
	allocate_vuse_optype, allocate_v_must_def_optype): Delete.
	(free_uses, free_defs, free_vuses, free_v_may_defs, free_v_must_defs):
	Change from functions to static variable list heads.
	(opbuild_initialize_virtual): New.  Initialize a virtual build list.
	(opbuild_initialize_real): New.  Initialize a virtual build list.
	(opbuild_free): New.  Free a build list.
	(opbuild_num_elems): New.  Number of items in a list.
	(opbuild_append_real): New.  Add a real (tree *) operand.
	(opbuild_append_virtual): New.  Add and sort a virtual (tree) operand.
	(opbuild_first): New.  Return first element index in a list.
	(opbuild_next): New.  Return next element in a list.
	(opbuild_elem_real): New.  Return real element.
	(opbuild_elem_virtual): New.  Return virtual element.
	(opbuild_elem_uid): New.  Return UID of virtual element.
	(opbuild_clear): New.  Reset an operand list.
	(opbuild_remove_elem): New.  Remove an element form a list.
	(ssa_operands_active): New.  Return true if operand cache is active.
	(init_ssa_operands, fini_ssa_operands): Initialize new implementation.
	(ssa_operand_alloc): New.  Allocate memory from an operand chunk.
	(correct_use_link): Use use_operand_p.
	(finalize_ssa_uses, finalize_ssa_v_may_defs, finalize_ssa_defs,
	finalize_ssa_vuses, finalize_ssa_v_must_defs): New implmentation.
	(cleanup_v_may_defs): Use new implmentation.
	(finalize_ssa_stmt_operands, start_ssa_stmt_operands): New
	implementation.
	(append_def, append_use, append_v_may_def, append_vuse,
	append_v_must_def): Call opbuild_append routine instead of using varray.
	(build_ssa_operands): Simplify to simply use stmt, don't maintain a
	global parse_old_ops variable.
	(free_ssa_operands): New implementation.
	(update_stmt_operands): Move.  Change argument to build_ssa_operands.
	(copy_virtual_operands): Move. New generic implementation.
	(create_ssa_artficial_load_stmt): Move. New implementation.
	(swap_tree_operands): Update for new implementation.
	(get_expr_operands): Add stmt parameter to calls to swap_tree_operands.
	(add_call_clobber_ops, add_call_read_ops): Initialize opbuild list
	rather than a varray.
	(verify_imm_links): Use use_operand_p.
	(dump_immediate_uses_for): If the immediate use variable is a virtual
	variable, show the virtual ops in the stmt.
	* tree-ssa-operands.h (def_operand_p): No longer a structure.
	(NULL_DEF_OPERAND_P): Now a #define.
	(def_optype_d, use_optype_d, v_def_use_operand_type, v_may_def_optype_d,
	vuse_operand_type, vuse_optype_d, v_must_def_optype_d): Delete.
	(def_optype_d, use_optype_d, maydef_optype_d, vuse_optype_d,
	mustdef_optype_d): New.  Use Linked list representation.
	(SSA_OPERAND_MEMORY_SIZE): New.  Size of operand memory chunk.
	(struct ssa_operand_memory_d): New.  Allocated Chunk node.
	(struct stmt_operands_d): Change to new pointers that are not GTY.
	(STMT_USE_OPS, NUM_USES, SET_USE_OP, STMT_DEF_OPS, NUM_DEFS, SET_DEF_OP,
	STMT_V_MAY_DEF_OPS, NUM_V_MAY_DEFS, SET_V_MAY_DEF_RESULT,
	SET_V_MAY_DEF_OP, STMT_VUSE_OPS, NUM_VUSES, SET_VUSE_OP,
	STMT_V_MUST_DEF_OPS, NUM_V_MUST_DEFS, SET_V_MUST_DEF_RESULT,
	SET_V_MUST_DEF_KILL): Delete.
	(V_MAY_DEF_OPS, V_MAY_DEF_RESULT_PTR, V_MAY_DEF_RESULT,
	V_MAY_DEF_OP_PTR, V_MAY_DEF_OP): Rename to MAYDEF_*.
	(V_MUST_DEF_OPS, V_MUST_DEF_RESULT_PTR, V_MUST_DEF_RESULT,
	V_MUST_DEF_KILL_PTR, V_MUST_DEF_KILL): Rename to MUSTDEF_*.
	(enum ssa_op_iter_type): Operand iterator typechecking values.
	(struct ssa_operand_iterator_d): Use linked lists of operands.
	(SSA_OP_VMUSTDEFKILL): Rename to SSA_OP_VMUSTKILL.
	(FOR_EACH_SSA_MAYDEF_OPERAND, FOR_EACH_SSA_MUSTDEF_OPERAND,
	FOR_EACH_SSA_MUST_AND_MAY_DEF_OPERAND): Use op_iter_next_maymustdef.
	(FOR_EACH_PHI_ARG): New.  Iterate over PHI arguments.
	(FOR_EACH_PHI_OR_STMT_USE): New.  Iterate over PHI or stmt uses.
	(FOR_EACH_PHI_OR_STMT_DEF): New.  Iterate over PHI or stmt defs.
	(SINGLE_SSA_TREE_OPERAND, SINGLE_SSA_USE_OPERAND,
	SINGLE_SSA_DEF_OPERAND, ZERO_SSA_OPERANDS, NUM_SSA_OPERANDS): New.
	* tree-ssa-opfinalize.h: New.  Function templates for expansion.
	(FINALIZE_ALLOC): Expands into alloc_def, alloc_use, alloc_maydef,
	alloc_vuse, and alloc_mustdef.
	(FINALIZE_FUNC): Expands into finalize_ssa_def_ops,
	finalize_ssa_use_ops, finalize_ssa_v_may_def_ops, finalize_ssa_vuse_ops,
	and finalize_ssa_v_must_def_ops.
	* tree-ssa-pre.c (add_to_sets): Pass tree to vn_add.
	(create_value_expr_from): Use stmt not vuse_optype as a parameter. Pass
	stmt around.
	(compute_avail): Use generic iterator interface.
	* tree-ssa-propagate.c (first_vdef): Use generic operand interface.
	(stmt_makes_single_load, stmt_makes_single_store): Use
	ZERO_SSA_OPERANDS.
	* tree-ssa-sink.c (is_hidden_global_store): Use ZERO_SSA_OPERANDS.
	(statement_sink_location): Use generic interface.
	* tree-ssa.c (verify_ssa):  Use %p in fprintf.  Use generic interface.
	(delete_tree_ssa): Don't call release_defs.  Call release_ssa_name and
	reset the immediate use link nodes.
	(stmt_references_memory_p): Use ZERO_SSA_OPERANDS.
	* tree-ssanames.c (make_ssa_name): Use use_operand_p.
	* tree-tailcall.c (find_tail_calls): Use ZERO_SSA_OPERANDS.
	(eliminate_tail_call): Use generic operand interface.
	* tree-vect-analyze.c (vect_analyze_data_refs): Use ZERO_SSA_OPERANDS.
	(vect_mark_relevant, vect_mark_stmts_to_be_vectorized): Use generic
	interface.
	* tree-vect-transform.c (update_vuses_to_preheader): Use generic
	interface.
	* tree-vectorizer.c (rename_variables_in_bb): Use generic interface.
	* tree-vn.c (struct val_expr_pair_d): Cache statment pointer instead of
	vuse_optype.
	(vn_compute, val_expr_pair_hash, vn_add, vn_lookup, vn_lookup_or_add):
	Use statement pointer instead of vuse_optype.  Use generic interface.
	* tree-vrp.c (maybe_add_assert_expr): Use generic interface.
	(stmt_interesting_for_vrp, vrp_visit_stmt): Use ZERO_SSA_OPERANDS.
	* tree.h (struct ssa_imm_use_d): Renamed to ssa_use_operand_d.
	(tree_ssa_name, phi_arg_d): Use ssa_use_operand_d.
	* doc/tree-ssa.texi: Update documentation for operand interface.


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

1 files changed, 386 insertions, 257 deletions

diff --git a/gcc/tree-flow-inline.h b/gcc/tree-flow-inline.h
index 5da85e049e1..3fa6259aa8e 100644
--- a/gcc/tree-flow-inline.h
+++ b/gcc/tree-flow-inline.h
@@ -186,7 +186,7 @@ stmt_modified_p (tree t)
 
 /* Delink an immediate_uses node from its chain.  */
 static inline void
-delink_imm_use (ssa_imm_use_t *linknode)
+delink_imm_use (ssa_use_operand_t *linknode)
 {
   /* Return if this node is not in a list.  */
   if (linknode->prev == NULL)
@@ -200,7 +200,7 @@ delink_imm_use (ssa_imm_use_t *linknode)
 
 /* 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_imm_use_to_list (ssa_use_operand_t *linknode, ssa_use_operand_t *list)
 {
   /* Link the new node at the head of the list.  If we are in the process of 
      traversing the list, we won't visit any new nodes added to it.  */
@@ -212,9 +212,9 @@ link_imm_use_to_list (ssa_imm_use_t *linknode, ssa_imm_use_t *list)
 
 /* Link ssa_imm_use node LINKNODE into the chain for DEF.  */
 static inline void
-link_imm_use (ssa_imm_use_t *linknode, tree def)
+link_imm_use (ssa_use_operand_t *linknode, tree def)
 {
-  ssa_imm_use_t *root;
+  ssa_use_operand_t *root;
 
   if (!def || TREE_CODE (def) != SSA_NAME)
     linknode->prev = NULL;
@@ -241,7 +241,7 @@ set_ssa_use_from_ptr (use_operand_p use, tree 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)
+link_imm_use_stmt (ssa_use_operand_t *linknode, tree def, tree stmt)
 {
   if (stmt)
     link_imm_use (linknode, def);
@@ -252,7 +252,7 @@ link_imm_use_stmt (ssa_imm_use_t *linknode, tree def, tree 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)
+relink_imm_use (ssa_use_operand_t *node, ssa_use_operand_t *old)
 {
   /* The node one had better be in the same list.  */
   gcc_assert (*(old->use) == *(node->use));
@@ -270,7 +270,7 @@ relink_imm_use (ssa_imm_use_t *node, ssa_imm_use_t *old)
 /* 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)
+relink_imm_use_stmt (ssa_use_operand_t *linknode, ssa_use_operand_t *old, tree stmt)
 {
   if (stmt)
     relink_imm_use (linknode, old);
@@ -318,7 +318,7 @@ first_safe_imm_use (imm_use_iterator *imm, tree var)
 static inline use_operand_p
 next_safe_imm_use (imm_use_iterator *imm)
 {
-  ssa_imm_use_t *ptr;
+  ssa_use_operand_t *ptr;
   use_operand_p old;
 
   old = imm->imm_use;
@@ -405,7 +405,7 @@ next_readonly_imm_use (imm_use_iterator *imm)
 static inline bool
 has_zero_uses (tree var)
 {
-  ssa_imm_use_t *ptr;
+  ssa_use_operand_t *ptr;
   ptr = &(SSA_NAME_IMM_USE_NODE (var));
   /* A single use means there is no items in the list.  */
   return (ptr == ptr->next);
@@ -415,7 +415,7 @@ has_zero_uses (tree var)
 static inline bool
 has_single_use (tree var)
 {
-  ssa_imm_use_t *ptr;
+  ssa_use_operand_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);
@@ -426,7 +426,7 @@ has_single_use (tree var)
 static inline bool
 single_imm_use (tree var, use_operand_p *use_p, tree *stmt)
 {
-  ssa_imm_use_t *ptr;
+  ssa_use_operand_t *ptr;
 
   ptr = &(SSA_NAME_IMM_USE_NODE (var));
   if (ptr != ptr->next && ptr == ptr->next->next)
@@ -444,7 +444,7 @@ single_imm_use (tree var, use_operand_p *use_p, tree *stmt)
 static inline unsigned int
 num_imm_uses (tree var)
 {
-  ssa_imm_use_t *ptr, *start;
+  ssa_use_operand_t *ptr, *start;
   unsigned int num;
 
   start = &(SSA_NAME_IMM_USE_NODE (var));
@@ -455,46 +455,6 @@ num_imm_uses (tree var)
   return num;
 }
 
-/* Return the definitions present in ANN, a statement annotation.
-   Return NULL if this annotation contains no definitions.  */
-static inline def_optype
-get_def_ops (stmt_ann_t ann)
-{
-  return ann ? ann->operands.def_ops : NULL;
-}
-
-/* Return the uses present in ANN, a statement annotation.
-   Return NULL if this annotation contains no uses.  */
-static inline use_optype
-get_use_ops (stmt_ann_t ann)
-{
-  return ann ? ann->operands.use_ops : NULL;
-}
-
-/* Return the virtual may-defs present in ANN, a statement
-   annotation.
-   Return NULL if this annotation contains no virtual may-defs.  */
-static inline v_may_def_optype
-get_v_may_def_ops (stmt_ann_t ann)
-{
-  return ann ? ann->operands.v_may_def_ops : NULL;
-}
-
-/* Return the virtual uses present in ANN, a statement annotation.
-   Return NULL if this annotation contains no virtual uses.  */
-static inline vuse_optype
-get_vuse_ops (stmt_ann_t ann)
-{
-  return ann ? ann->operands.vuse_ops : NULL;
-}
-
-/* Return the virtual must-defs present in ANN, a statement
-   annotation.  Return NULL if this annotation contains no must-defs.*/
-static inline v_must_def_optype
-get_v_must_def_ops (stmt_ann_t ann)
-{
-  return ann ? ann->operands.v_must_def_ops : NULL;
-}
 
 /* Return the tree pointer to by USE.  */ 
 static inline tree
@@ -507,80 +467,14 @@ get_use_from_ptr (use_operand_p use)
 static inline tree
 get_def_from_ptr (def_operand_p def)
 {
-  return *(def.def);
-}
-
-/* Return a pointer to the tree that is at INDEX in the USES array.  */
-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 a def_operand_p pointer for element INDEX of DEFS.  */
-static inline def_operand_p
-get_def_op_ptr (def_optype defs, unsigned int index)
-{
-  gcc_assert (index < defs->num_defs);
-  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
-get_v_may_def_result_ptr(v_may_def_optype v_may_defs, unsigned int index)
-{
-  def_operand_p op;
-  gcc_assert (index < v_may_defs->num_v_may_defs);
-  op.def = &(v_may_defs->v_may_defs[index].def);
-  return op;
-}
-
-/* Return a use_operand_p that is the V_MAY_DEF_OP for the V_MAY_DEF at
-   INDEX in the V_MAY_DEFS array.  */
-static inline use_operand_p
-get_v_may_def_op_ptr(v_may_def_optype v_may_defs, unsigned int index)
-{
-  gcc_assert (index < v_may_defs->num_v_may_defs);
-  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)
-{
-  gcc_assert (index < vuses->num_vuses);
-  return &(vuses->vuses[index].imm_use);
-}
-
-/* Return a def_operand_p that is the V_MUST_DEF_RESULT for the
-   V_MUST_DEF at INDEX in the V_MUST_DEFS array.  */
-static inline def_operand_p
-get_v_must_def_result_ptr (v_must_def_optype v_must_defs, unsigned int index)
-{
-  def_operand_p op;
-  gcc_assert (index < v_must_defs->num_v_must_defs);
-  op.def = &(v_must_defs->v_must_defs[index].def);
-  return op;
-}
-
-/* Return a use_operand_p that is the V_MUST_DEF_KILL for the 
-   V_MUST_DEF at INDEX in the V_MUST_DEFS array.  */
-static inline use_operand_p
-get_v_must_def_kill_ptr (v_must_def_optype v_must_defs, unsigned int index)
-{
-  gcc_assert (index < v_must_defs->num_v_must_defs);
-  return &(v_must_defs->v_must_defs[index].imm_use);
+  return *def;
 }
 
 /* Return a def_operand_p pointer for the result of PHI.  */
 static inline def_operand_p
 get_phi_result_ptr (tree phi)
 {
-  def_operand_p op;
-  op.def = &(PHI_RESULT_TREE (phi));
-  return op;
+  return &(PHI_RESULT_TREE (phi));
 }
 
 /* Return a use_operand_p pointer for argument I of phinode PHI.  */
@@ -590,29 +484,6 @@ get_phi_arg_def_ptr (tree phi, int i)
   return &(PHI_ARG_IMM_USE_NODE (phi,i));
 }
 
-/* Delink all immediate_use information for STMT.  */
-static inline void
-delink_stmt_imm_use (tree stmt)
-{
-   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);
-
-   for (x = 0; x < NUM_USES (uses); x++)
-     delink_imm_use (&(uses->uses[x]));
-
-   for (x = 0; x < NUM_VUSES (vuses); x++)
-     delink_imm_use (&(vuses->vuses[x].imm_use));
-
-   for (x = 0; x < NUM_V_MAY_DEFS (v_may_defs); x++)
-     delink_imm_use (&(v_may_defs->v_may_defs[x].imm_use));
-
-   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 bitmap of addresses taken by STMT, or NULL if it takes
    no addresses.  */
@@ -963,23 +834,37 @@ op_iter_done (ssa_op_iter *ptr)
 static inline use_operand_p
 op_iter_next_use (ssa_op_iter *ptr)
 {
-  if (ptr->use_i < ptr->num_use)
+  use_operand_p use_p;
+#ifdef ENABLE_CHECKING
+  gcc_assert (ptr->iter_type == ssa_op_iter_use);
+#endif
+  if (ptr->uses)
     {
-      return USE_OP_PTR (ptr->ops->use_ops, (ptr->use_i)++);
+      use_p = USE_OP_PTR (ptr->uses);
+      ptr->uses = ptr->uses->next;
+      return use_p;
     }
-  if (ptr->vuse_i < ptr->num_vuse)
+  if (ptr->vuses)
     {
-      return VUSE_OP_PTR (ptr->ops->vuse_ops, (ptr->vuse_i)++);
+      use_p = VUSE_OP_PTR (ptr->vuses);
+      ptr->vuses = ptr->vuses->next;
+      return use_p;
     }
-  if (ptr->v_mayu_i < ptr->num_v_mayu)
+  if (ptr->mayuses)
     {
-      return V_MAY_DEF_OP_PTR (ptr->ops->v_may_def_ops,
-			       (ptr->v_mayu_i)++);
+      use_p = MAYDEF_OP_PTR (ptr->mayuses);
+      ptr->mayuses = ptr->mayuses->next;
+      return use_p;
     }
-  if (ptr->v_mustu_i < ptr->num_v_mustu)
+  if (ptr->mustkills)
     {
-      return V_MUST_DEF_KILL_PTR (ptr->ops->v_must_def_ops,
-				  (ptr->v_mustu_i)++);
+      use_p = MUSTDEF_KILL_PTR (ptr->mustkills);
+      ptr->mustkills = ptr->mustkills->next;
+      return use_p;
+    }
+  if (ptr->phi_i < ptr->num_phi)
+    {
+      return PHI_ARG_DEF_PTR (ptr->phi_stmt, (ptr->phi_i)++);
     }
   ptr->done = true;
   return NULL_USE_OPERAND_P;
@@ -989,19 +874,27 @@ op_iter_next_use (ssa_op_iter *ptr)
 static inline def_operand_p
 op_iter_next_def (ssa_op_iter *ptr)
 {
-  if (ptr->def_i < ptr->num_def)
+  def_operand_p def_p;
+#ifdef ENABLE_CHECKING
+  gcc_assert (ptr->iter_type == ssa_op_iter_def);
+#endif
+  if (ptr->defs)
     {
-      return DEF_OP_PTR (ptr->ops->def_ops, (ptr->def_i)++);
+      def_p = DEF_OP_PTR (ptr->defs);
+      ptr->defs = ptr->defs->next;
+      return def_p;
     }
-  if (ptr->v_mustd_i < ptr->num_v_mustd)
+  if (ptr->mustdefs)
     {
-      return V_MUST_DEF_RESULT_PTR (ptr->ops->v_must_def_ops, 
-					(ptr->v_mustd_i)++);
+      def_p = MUSTDEF_RESULT_PTR (ptr->mustdefs);
+      ptr->mustdefs = ptr->mustdefs->next;
+      return def_p;
     }
-  if (ptr->v_mayd_i < ptr->num_v_mayd)
+  if (ptr->maydefs)
     {
-      return V_MAY_DEF_RESULT_PTR (ptr->ops->v_may_def_ops,
-					   (ptr->v_mayd_i)++);
+      def_p = MAYDEF_RESULT_PTR (ptr->maydefs);
+      ptr->maydefs = ptr->maydefs->next;
+      return def_p;
     }
   ptr->done = true;
   return NULL_DEF_OPERAND_P;
@@ -1011,68 +904,100 @@ op_iter_next_def (ssa_op_iter *ptr)
 static inline tree
 op_iter_next_tree (ssa_op_iter *ptr)
 {
-  if (ptr->use_i < ptr->num_use)
+  tree val;
+#ifdef ENABLE_CHECKING
+  gcc_assert (ptr->iter_type == ssa_op_iter_tree);
+#endif
+  if (ptr->uses)
     {
-      return USE_OP (ptr->ops->use_ops, (ptr->use_i)++);
+      val = USE_OP (ptr->uses);
+      ptr->uses = ptr->uses->next;
+      return val;
     }
-  if (ptr->vuse_i < ptr->num_vuse)
+  if (ptr->vuses)
     {
-      return VUSE_OP (ptr->ops->vuse_ops, (ptr->vuse_i)++);
+      val = VUSE_OP (ptr->vuses);
+      ptr->vuses = ptr->vuses->next;
+      return val;
     }
-  if (ptr->v_mayu_i < ptr->num_v_mayu)
+  if (ptr->mayuses)
     {
-      return V_MAY_DEF_OP (ptr->ops->v_may_def_ops, (ptr->v_mayu_i)++);
+      val = MAYDEF_OP (ptr->mayuses);
+      ptr->mayuses = ptr->mayuses->next;
+      return val;
     }
-  if (ptr->v_mustu_i < ptr->num_v_mustu)
+  if (ptr->mustkills)
     {
-      return V_MUST_DEF_KILL (ptr->ops->v_must_def_ops, (ptr->v_mustu_i)++);
+      val = MUSTDEF_KILL (ptr->mustkills);
+      ptr->mustkills = ptr->mustkills->next;
+      return val;
     }
-  if (ptr->def_i < ptr->num_def)
+  if (ptr->defs)
     {
-      return DEF_OP (ptr->ops->def_ops, (ptr->def_i)++);
+      val = DEF_OP (ptr->defs);
+      ptr->defs = ptr->defs->next;
+      return val;
     }
-  if (ptr->v_mustd_i < ptr->num_v_mustd)
+  if (ptr->mustdefs)
     {
-      return V_MUST_DEF_RESULT (ptr->ops->v_must_def_ops, 
-					(ptr->v_mustd_i)++);
+      val = MUSTDEF_RESULT (ptr->mustdefs);
+      ptr->mustdefs = ptr->mustdefs->next;
+      return val;
     }
-  if (ptr->v_mayd_i < ptr->num_v_mayd)
+  if (ptr->maydefs)
     {
-      return V_MAY_DEF_RESULT (ptr->ops->v_may_def_ops,
-					   (ptr->v_mayd_i)++);
+      val = MAYDEF_RESULT (ptr->maydefs);
+      ptr->maydefs = ptr->maydefs->next;
+      return val;
     }
+
+  ptr->done = true;
+  return NULL_TREE;
+
+}
+
+
+/* This functiins clears the iterator PTR, and marks it done.  This is normally
+   used to prevent warnings in the compile about might be uninitailzied
+   components.  */
+
+static inline void
+clear_and_done_ssa_iter (ssa_op_iter *ptr)
+{
+  ptr->defs = NULL;
+  ptr->uses = NULL;
+  ptr->vuses = NULL;
+  ptr->maydefs = NULL;
+  ptr->mayuses = NULL;
+  ptr->mustdefs = NULL;
+  ptr->mustkills = NULL;
+  ptr->iter_type = ssa_op_iter_none;
+  ptr->phi_i = 0;
+  ptr->num_phi = 0;
+  ptr->phi_stmt = NULL_TREE;
   ptr->done = true;
-  return NULL;
 }
 
 /* Initialize the iterator PTR to the virtual defs in STMT.  */
 static inline void
 op_iter_init (ssa_op_iter *ptr, tree stmt, int flags)
 {
-  stmt_operands_p ops;
-  stmt_ann_t ann = get_stmt_ann (stmt);
+#ifdef ENABLE_CHECKING
+  gcc_assert (stmt_ann (stmt));
+#endif
 
-  ops = &(ann->operands);
+  ptr->defs = (flags & SSA_OP_DEF) ? DEF_OPS (stmt) : NULL;
+  ptr->uses = (flags & SSA_OP_USE) ? USE_OPS (stmt) : NULL;
+  ptr->vuses = (flags & SSA_OP_VUSE) ? VUSE_OPS (stmt) : NULL;
+  ptr->maydefs = (flags & SSA_OP_VMAYDEF) ? MAYDEF_OPS (stmt) : NULL;
+  ptr->mayuses = (flags & SSA_OP_VMAYUSE) ? MAYDEF_OPS (stmt) : NULL;
+  ptr->mustdefs = (flags & SSA_OP_VMUSTDEF) ? MUSTDEF_OPS (stmt) : NULL;
+  ptr->mustkills = (flags & SSA_OP_VMUSTKILL) ? MUSTDEF_OPS (stmt) : NULL;
   ptr->done = false;
-  ptr->ops = ops;
-  ptr->num_def = (flags & SSA_OP_DEF) ? NUM_DEFS (ops->def_ops) : 0;
-  ptr->num_use = (flags & SSA_OP_USE) ? NUM_USES (ops->use_ops) : 0;
-  ptr->num_vuse = (flags & SSA_OP_VUSE) ? NUM_VUSES (ops->vuse_ops) : 0;
-  ptr->num_v_mayu = (flags & SSA_OP_VMAYUSE)
-		     ?  NUM_V_MAY_DEFS (ops->v_may_def_ops) : 0;
-  ptr->num_v_mayd = (flags & SSA_OP_VMAYDEF) 
-		     ?  NUM_V_MAY_DEFS (ops->v_may_def_ops) : 0;
-  ptr->num_v_mustu = (flags & SSA_OP_VMUSTDEFKILL)
-                     ? NUM_V_MUST_DEFS (ops->v_must_def_ops) : 0;
-  ptr->num_v_mustd = (flags & SSA_OP_VMUSTDEF) 
-		     ? NUM_V_MUST_DEFS (ops->v_must_def_ops) : 0;
-  ptr->def_i = 0;
-  ptr->use_i = 0;
-  ptr->vuse_i = 0;
-  ptr->v_mayu_i = 0;
-  ptr->v_mayd_i = 0;
-  ptr->v_mustu_i = 0;
-  ptr->v_mustd_i = 0;
+
+  ptr->phi_i = 0;
+  ptr->num_phi = 0;
+  ptr->phi_stmt = NULL_TREE;
 }
 
 /* Initialize iterator PTR to the use operands in STMT based on FLAGS. Return
@@ -1081,6 +1006,7 @@ static inline use_operand_p
 op_iter_init_use (ssa_op_iter *ptr, tree stmt, int flags)
 {
   op_iter_init (ptr, stmt, flags);
+  ptr->iter_type = ssa_op_iter_use;
   return op_iter_next_use (ptr);
 }
 
@@ -1090,6 +1016,7 @@ static inline def_operand_p
 op_iter_init_def (ssa_op_iter *ptr, tree stmt, int flags)
 {
   op_iter_init (ptr, stmt, flags);
+  ptr->iter_type = ssa_op_iter_def;
   return op_iter_next_def (ptr);
 }
 
@@ -1099,85 +1026,53 @@ static inline tree
 op_iter_init_tree (ssa_op_iter *ptr, tree stmt, int flags)
 {
   op_iter_init (ptr, stmt, flags);
+  ptr->iter_type = ssa_op_iter_tree;
   return op_iter_next_tree (ptr);
 }
 
 /* Get the next iterator mustdef value for PTR, returning the mustdef values in
    KILL and DEF.  */
 static inline void
-op_iter_next_mustdef (use_operand_p *kill, def_operand_p *def, ssa_op_iter *ptr)
+op_iter_next_maymustdef (use_operand_p *use, def_operand_p *def, 
+			 ssa_op_iter *ptr)
 {
-  if (ptr->v_mustu_i < ptr->num_v_mustu)
+#ifdef ENABLE_CHECKING
+  gcc_assert (ptr->iter_type == ssa_op_iter_maymustdef);
+#endif
+  if (ptr->mayuses)
     {
-      *def = V_MUST_DEF_RESULT_PTR (ptr->ops->v_must_def_ops, ptr->v_mustu_i);
-      *kill = V_MUST_DEF_KILL_PTR (ptr->ops->v_must_def_ops, (ptr->v_mustu_i)++);
+      *def = MAYDEF_RESULT_PTR (ptr->mayuses);
+      *use = MAYDEF_OP_PTR (ptr->mayuses);
+      ptr->mayuses = ptr->mayuses->next;
       return;
     }
-  else
-    {
-      *def = NULL_DEF_OPERAND_P;
-      *kill = NULL_USE_OPERAND_P;
-    }
-  ptr->done = true;
-  return;
-}
 
-/* Get the next iterator maydef value for PTR, returning the maydef values in
-   USE and DEF.  */
-static inline void
-op_iter_next_maydef (use_operand_p *use, def_operand_p *def, ssa_op_iter *ptr)
-{
-  if (ptr->v_mayu_i < ptr->num_v_mayu)
+  if (ptr->mustkills)
     {
-      *def = V_MAY_DEF_RESULT_PTR (ptr->ops->v_may_def_ops, ptr->v_mayu_i);
-      *use = V_MAY_DEF_OP_PTR (ptr->ops->v_may_def_ops, (ptr->v_mayu_i)++);
+      *def = MUSTDEF_RESULT_PTR (ptr->mustkills);
+      *use = MUSTDEF_KILL_PTR (ptr->mustkills);
+      ptr->mustkills = ptr->mustkills->next;
       return;
     }
-  else
-    {
-      *def = NULL_DEF_OPERAND_P;
-      *use = NULL_USE_OPERAND_P;
-    }
-  ptr->done = true;
-  return;
-}
 
-/* Get the next iterator mustdef or maydef value for PTR, returning the
-   mustdef or maydef values in KILL and DEF.  */
-static inline void
-op_iter_next_must_and_may_def (use_operand_p *kill,
-			       def_operand_p *def,
-			       ssa_op_iter *ptr)
-{
-  if (ptr->v_mustu_i < ptr->num_v_mustu)
-    {
-      *def = V_MUST_DEF_RESULT_PTR (ptr->ops->v_must_def_ops, ptr->v_mustu_i);
-      *kill = V_MUST_DEF_KILL_PTR (ptr->ops->v_must_def_ops, (ptr->v_mustu_i)++);
-      return;
-    }
-  else if (ptr->v_mayu_i < ptr->num_v_mayu)
-    {
-      *def = V_MAY_DEF_RESULT_PTR (ptr->ops->v_may_def_ops, ptr->v_mayu_i);
-      *kill = V_MAY_DEF_OP_PTR (ptr->ops->v_may_def_ops, (ptr->v_mayu_i)++);
-      return;
-    }
-  else
-    {
-      *def = NULL_DEF_OPERAND_P;
-      *kill = NULL_USE_OPERAND_P;
-    }
+  *def = NULL_DEF_OPERAND_P;
+  *use = NULL_USE_OPERAND_P;
   ptr->done = true;
   return;
 }
 
+
 /* Initialize iterator PTR to the operands in STMT.  Return the first operands
    in USE and DEF.  */
 static inline void
 op_iter_init_maydef (ssa_op_iter *ptr, tree stmt, use_operand_p *use, 
 		     def_operand_p *def)
 {
+  gcc_assert (TREE_CODE (stmt) != PHI_NODE);
+
   op_iter_init (ptr, stmt, SSA_OP_VMAYUSE);
-  op_iter_next_maydef (use, def, ptr);
+  ptr->iter_type = ssa_op_iter_maymustdef;
+  op_iter_next_maymustdef (use, def, ptr);
 }
 
 
@@ -1187,8 +1082,11 @@ static inline void
 op_iter_init_mustdef (ssa_op_iter *ptr, tree stmt, use_operand_p *kill, 
 		     def_operand_p *def)
 {
-  op_iter_init (ptr, stmt, SSA_OP_VMUSTDEFKILL);
-  op_iter_next_mustdef (kill, def, ptr);
+  gcc_assert (TREE_CODE (stmt) != PHI_NODE);
+
+  op_iter_init (ptr, stmt, SSA_OP_VMUSTKILL);
+  ptr->iter_type = ssa_op_iter_maymustdef;
+  op_iter_next_maymustdef (kill, def, ptr);
 }
 
 /* Initialize iterator PTR to the operands in STMT.  Return the first operands
@@ -1197,10 +1095,241 @@ static inline void
 op_iter_init_must_and_may_def (ssa_op_iter *ptr, tree stmt,
 			       use_operand_p *kill, def_operand_p *def)
 {
-  op_iter_init (ptr, stmt, SSA_OP_VMUSTDEFKILL | SSA_OP_VMAYUSE);
-  op_iter_next_must_and_may_def (kill, def, ptr);
+  gcc_assert (TREE_CODE (stmt) != PHI_NODE);
+
+  op_iter_init (ptr, stmt, SSA_OP_VMUSTKILL|SSA_OP_VMAYUSE);
+  ptr->iter_type = ssa_op_iter_maymustdef;
+  op_iter_next_maymustdef (kill, def, ptr);
+}
+
+
+/* If there is a single opernad in STMT matching FLAGS, return it.  Otherwise
+   return NULL.  PTR is the iterator to use.  */
+static inline tree
+single_ssa_tree_operand (tree stmt, int flags)
+{
+  tree var;
+  ssa_op_iter iter;
+
+  var = op_iter_init_tree (&iter, stmt, flags);
+  if (op_iter_done (&iter))
+    return NULL_TREE;
+  op_iter_next_tree (&iter);
+  if (op_iter_done (&iter))
+    return var;
+  return NULL_TREE;
+}
+
+
+/* If there is a single opernad in STMT matching FLAGS, return it.  Otherwise
+   return NULL.  PTR is the iterator to use.  */
+static inline use_operand_p
+single_ssa_use_operand (tree stmt, int flags)
+{
+  use_operand_p var;
+  ssa_op_iter iter;
+
+  var = op_iter_init_use (&iter, stmt, flags);
+  if (op_iter_done (&iter))
+    return NULL_USE_OPERAND_P;
+  op_iter_next_use (&iter);
+  if (op_iter_done (&iter))
+    return var;
+  return NULL_USE_OPERAND_P;
+}
+
+
+
+/* If there is a single opernad in STMT matching FLAGS, return it.  Otherwise
+   return NULL.  PTR is the iterator to use.  */
+static inline def_operand_p
+single_ssa_def_operand (tree stmt, int flags)
+{
+  def_operand_p var;
+  ssa_op_iter iter;
+
+  var = op_iter_init_def (&iter, stmt, flags);
+  if (op_iter_done (&iter))
+    return NULL_DEF_OPERAND_P;
+  op_iter_next_def (&iter);
+  if (op_iter_done (&iter))
+    return var;
+  return NULL_DEF_OPERAND_P;
+}
+
+
+/* If there is a single opernad in STMT matching FLAGS, return it.  Otherwise
+   return NULL.  PTR is the iterator to use.  */
+static inline bool
+zero_ssa_operands (tree stmt, int flags)
+{
+  ssa_op_iter iter;
+
+  op_iter_init_tree (&iter, stmt, flags);
+  return op_iter_done (&iter);
 }
 
+
+/* Return the  number of opernads mathcing FLAGS in STMT.  */
+static inline int
+num_ssa_operands (tree stmt, int flags)
+{
+  ssa_op_iter iter;
+  int num = 0;
+
+  op_iter_init (&iter, stmt, flags);
+  for ( ; iter.defs; iter.defs = iter.defs->next)
+    num++;
+  for ( ; iter.uses; iter.uses = iter.uses->next)
+    num++;
+  for ( ; iter.vuses; iter.vuses = iter.vuses->next)
+    num++;
+  for ( ; iter.maydefs; iter.maydefs = iter.maydefs->next)
+    num++;
+  for ( ; iter.mayuses; iter.mayuses = iter.mayuses->next)
+    num++;
+  for ( ; iter.mustdefs; iter.mustdefs = iter.mustdefs->next)
+    num++;
+  for ( ; iter.mustkills; iter.mustkills = iter.mustkills->next)
+    num++;
+
+  return num;
+}
+
+
+/* Delink all immediate_use information for STMT.  */
+static inline void
+delink_stmt_imm_use (tree stmt)
+{
+   ssa_op_iter iter;
+   use_operand_p use_p;
+
+   if (ssa_operands_active ())
+     FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter,
+			       (SSA_OP_ALL_USES | SSA_OP_ALL_KILLS))
+       delink_imm_use (use_p);
+}
+
+
+/* This routine will compare all the operands matching FLAGS in STMT1 to those
+   in STMT2.  TRUE is returned if they are the same.  STMTs can be NULL.  */
+static inline bool
+compare_ssa_operands_equal (tree stmt1, tree stmt2, int flags)
+{
+  ssa_op_iter iter1, iter2;
+  tree op1 = NULL_TREE;
+  tree op2 = NULL_TREE;
+  bool look1, look2;
+
+  if (stmt1 == stmt2)
+    return true;
+
+  look1 = stmt1 && stmt_ann (stmt1);
+  look2 = stmt2 && stmt_ann (stmt2);
+
+  if (look1)
+    {
+      op1 = op_iter_init_tree (&iter1, stmt1, flags);
+      if (!look2)
+        return op_iter_done (&iter1);
+    }
+  else
+    clear_and_done_ssa_iter (&iter1);
+
+  if (look2)
+    {
+      op2 = op_iter_init_tree (&iter2, stmt2, flags);
+      if (!look1)
+        return op_iter_done (&iter2);
+    }
+  else
+    clear_and_done_ssa_iter (&iter2);
+
+  while (!op_iter_done (&iter1) && !op_iter_done (&iter2))
+    {
+      if (op1 != op2)
+	return false;
+      op1 = op_iter_next_tree (&iter1);
+      op2 = op_iter_next_tree (&iter2);
+    }
+
+  return (op_iter_done (&iter1) && op_iter_done (&iter2));
+}
+
+
+/* If there is a single DEF in the PHI node which matches FLAG, return it.
+   Otherwise return NULL_DEF_OPERAND_P.  */
+static inline tree
+single_phi_def (tree stmt, int flags)
+{
+  tree def = PHI_RESULT (stmt);
+  if ((flags & SSA_OP_DEF) && is_gimple_reg (def)) 
+    return def;
+  if ((flags & SSA_OP_VIRTUAL_DEFS) && !is_gimple_reg (def))
+    return def;
+  return NULL_TREE;
+}
+
+/* Initialize the iterator PTR for uses matching FLAGS in PHI.  FLAGS should
+   be either SSA_OP_USES or SAS_OP_VIRTUAL_USES.  */
+static inline use_operand_p
+op_iter_init_phiuse (ssa_op_iter *ptr, tree phi, int flags)
+{
+  tree phi_def = PHI_RESULT (phi);
+  int comp;
+
+  clear_and_done_ssa_iter (ptr);
+  ptr->done = false;
+
+  gcc_assert ((flags & (SSA_OP_USE | SSA_OP_VIRTUAL_USES)) != 0);
+
+  comp = (is_gimple_reg (phi_def) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES);
+    
+  /* if the PHI node deosn't the operand type we care about, we're done.  */
+  if ((flags & comp) == 0)
+    {
+      ptr->done = true;
+      return NULL_USE_OPERAND_P;
+    }
+
+  ptr->phi_stmt = phi;
+  ptr->num_phi = PHI_NUM_ARGS (phi);
+  ptr->iter_type = ssa_op_iter_use;
+  return op_iter_next_use (ptr);
+}
+
+
+/* Start an iterator for a PHI defintion.  */
+
+static inline def_operand_p
+op_iter_init_phidef (ssa_op_iter *ptr, tree phi, int flags)
+{
+  tree phi_def = PHI_RESULT (phi);
+  int comp;
+
+  clear_and_done_ssa_iter (ptr);
+  ptr->done = false;
+
+  gcc_assert ((flags & (SSA_OP_DEF | SSA_OP_VIRTUAL_DEFS)) != 0);
+
+  comp = (is_gimple_reg (phi_def) ? SSA_OP_DEF : SSA_OP_VIRTUAL_DEFS);
+    
+  /* if the PHI node deosn't the operand type we care about, we're done.  */
+  if ((flags & comp) == 0)
+    {
+      ptr->done = true;
+      return NULL_USE_OPERAND_P;
+    }
+
+  ptr->iter_type = ssa_op_iter_def;
+  /* The first call to op_iter_next_def will terminate the iterator since
+     all the fields are NULL.  Simply return the result here as the first and
+     therefore only result.  */
+  return PHI_RESULT_PTR (phi);
+}
+
+
+
 /* Return true if VAR cannot be modified by the program.  */
 
 static inline bool