[PATCH][RFC] Make virtual operands real operands (alias-improvements)

Richard Guenther rguenther@suse.de
Sun Jan 18 00:52:00 GMT 2009


On Sat, 17 Jan 2009, Richard Guenther wrote:

> 
> I am playing with transitioning the data structures used for the single
> virtual operand on the alias-improvements branch away from the
> virtual operands infrastructure we have.  This first patch removes
> that infrastructure and makes the single VUSE/VDEF use the regular
> SSA operands structures instead - by temporarily adding these
> possible two operands to the gimple_statement_with_memory_ops_base
> structure as vdef and vuse members (the SSA operands do not have
> embedded space for storing the operands itself).
> 
> In the end I think it should be possible to get rid of the
> distinction of a gimple statement with and without memory ops.
> The trick would be to move the VUSE and VDEF operand to the
> regular gimple_statement_with_ops op array and the operands
> to the regular def_ops/use_ops lists.  For the latter simply
> using the first entry and for the former appending it to the
> statement operands sounds doable - but I'd like to hear
> opinions on whether you think this is something that should
> be done on the branch at all (we still have the bitmaps for
> loaded and stored syms - though they are mostly unused and
> the information could be computed on-the-fly when needed).
> 
> I will at least try to remove the vdef_ops and vuse_ops so
> the overall structure size of gimple_statement_with_memory_ops_base
> will not grow.

Like the following.  Bootstrapped / tested on x86_64-unknown-linux-gnu.

We end up with SSA operand iterators which are a lot simpler - because
I decided to disallow iterating over only the virtual parts of
uses or defs - those can be accessed directly by gimple_vop_def
and gimple_vop_use, or of course gimple_vop/gimple_vuse.  The bulk
part of this patch makes replacements throughout the code.

This is the state I'd like to merge to trunk - the possibility
of getting rid of gimple_*_with_memory_ops* can be explored on
the trunk if wanted.

Would that be ok?

Thanks,
Richard.

2009-01-17  Richard Guenther  <rguenther@suse.de>

	* gimple.c (gimple_copy): Do not clear vdef or vuse ops.
	* gimple.h (gimple_statement_with_memory_ops_base): Remove
	vdef_ops and vuse_ops members.
	(gimple_vuse_ops): Remove.
	(gimple_vdef_ops): Likewise.
	(gimple_vuse_op): New function.
	(gimple_vdef_op): Likewise.
	* tree-flow-inline.h (op_iter_next_use): Simplify.
	(op_iter_next_def): Likewise.
	(op_iter_next_tree): Likewise.
	(clear_and_done_ssa_iter): Likewise.
	(op_iter_init): Skip virtual use/def if required.  Reject
	iterating over only the virtual parts.
	(op_iter_init_use): Reject iterating over only the virtual part.
	(op_iter_init_def): Likewise.
	(op_iter_next_vdef): Remove.
	(link_use_stmts_after): Adjust.
	* tree-ssa-operands.c (finalize_ssa_defs): Merge in
	finalize_ssa_vdefs.
	(finalize_ssa_uses): Merge in finalize_ssa_vuses.
	(finalize_ssa_vdefs): Remove.
	(finalize_ssa_vuse_ops): Likewise.
	(finalize_ssa_vuses): Likewise.
	(finalize_ssa_stmt_operands): Do not call them.
	(free_stmt_operands): Do not free stmt vops or vdefs.
	(copy_virtual_operands): Adjust.
	(push_stmt_changes): Adjust.
	* tree-ssa-operands.h (enum ssa_op_iter_type): Remove ssa_op_iter_vdef.
	(struct ssa_operand_iterator_d): Remove vuses and vdefs members.
	(SSA_OP_VMAYUSE): Remove.
	* lambda-code.c (can_put_in_inner_loop): Adjust.
	(can_put_after_inner_loop): Likewise.
	(perfect_nestify): Mark the vop for renaming.
	* tree-complex.c (update_all_vops): Remove.
	(expand_complex_move): Do not call it.
	* tree-data-ref.c (get_references_in_stmt): Adjust.
	(stores_from_loop): Likewise.
	* tree-dfa.c (collect_dfa_stats): Likewise.
	* tree-into-ssa.c (rewrite_update_stmt): Adjust.
	* tree-loop-distribution.c (generate_memset_zero): Likewise.
	(rdg_flag_uses): Likewise.
	* tree-predcom.c (get_init_expr): Likewise.
	(mark_virtual_ops_for_renaming): Likewise.
	(initialize_root_vars): Likewise.
	(initialize_root_vars_lm): Likewise.
	(prepare_initializers_chain): Likewise.
	* tree-sra.c (mark_all_v_defs_stmt): Remove.
	(mark_all_v_defs_seq): Adjust.
	(sra_replace): Remove VOPs properly.
	(scalarize_use): Adjust.
	(scalarize_copy): Likewise.
	(scalarize_init): Likewise.
	(scalarize_ldst): Likewise.
	* tree-ssa-ccp.c (surely_varying_stmt_p): Adjust.
	(gimplify_and_update_call_from_tree): Do not copy virtual
	operands.
	* tree-ssa-coalesce.c (create_outofssa_var_map): Adjust.
	* tree-ssa-copy.c (propagate_tree_value_into_stmt): Do not
	copy virtual operands.
	(stmt_may_generate_copy): Adjust.
	* tree-ssa-dom.c (eliminate_redundant_computations): Adjust.
	* tree-ssa-dse.c (dse_optimize_stmt): Adjust.
	* tree-ssa-ifcombine.c (bb_no_side_effects_p): Adjust.
	* tree-ssa-loop-im.c (movement_possibility): Adjust.
	(determine_max_movement): Likewise.
	(gather_mem_refs_stmt): Likewise.
	* tree-ssa-loop-ivcanon.c (empty_loop_p): Adjust.
	* tree-ssa-loop-prefetch.c (gather_memory_references): Adjust.
	* tree-ssa-phiprop.c (phivn_valid_p): Adjust.
	(propagate_with_phi): Likewise.
	* tree-ssa-propagate.c (update_call_from_tree): Do not
	copy virtual operands.
	(stmt_makes_single_load): Adjust.
	(stmt_makes_single_store): Likewise.
	* tree-ssa-reassoc.c (get_rank): Adjust.
	* tree-ssa-sink.c (is_hidden_global_store): Adjust.
	(statement_sink_location): Likewise.
	* tree-ssa-ter.c (is_replaceable_p): Adjust.
	(process_replaceable): Likewise.
	(find_replaceable_in_bb): Likewise.
	* tree-ssa.c (verify_ssa): Adjust.
	(delete_tree_ssa): Do not free virtual ops.
	(warn_uninitialized_var): Adjust.
	* tree-vect-analyze.c (vect_stmt_relevant_p): Adjust.
	* tree-vect-transform.c (vectorizable_call): Adjust.
	(vect_gen_widened_results_half): Likewise.
	(vectorizable_conversion): Likewise.
	(vect_create_mask_and_perm): Likewise.
	* tree-vrp.c (stmt_interesting_for_vrp): Adjust.
	(vrp_visit_stmt): Adjust.

Index: alias-improvements/gcc/gimple.c
===================================================================
*** alias-improvements.orig/gcc/gimple.c	2009-01-17 21:54:37.000000000 +0100
--- alias-improvements/gcc/gimple.c	2009-01-17 21:54:38.000000000 +0100
*************** gimple_copy (gimple stmt)
*** 2208,2215 ****
  
        if (gimple_has_mem_ops (stmt))
  	{
- 	  gimple_set_vdef_ops (copy, NULL);
- 	  gimple_set_vuse_ops (copy, NULL);
  	  gimple_set_vdef (copy, NULL_TREE);
  	  gimple_set_vuse (copy, NULL_TREE);
  	  copy->gsmem.membase.stores = NULL;
--- 2208,2213 ----
Index: alias-improvements/gcc/gimple.h
===================================================================
*** alias-improvements.orig/gcc/gimple.h	2009-01-17 21:54:37.000000000 +0100
--- alias-improvements/gcc/gimple.h	2009-01-17 21:54:38.000000000 +0100
*************** struct gimple_statement_with_memory_ops_
*** 363,386 ****
    /* [ WORD 1-7 ]  */
    struct gimple_statement_with_ops_base opbase;
  
!   /* [ WORD 8-9 ]  
!      Vectors for virtual operands.
!      ???  As these contain one VUSE/VDEF at most we can merge them
!      with the real operand vectors easily.  */
!   struct def_optype_d GTY((skip (""))) *vdef_ops;
!   struct use_optype_d GTY((skip (""))) *vuse_ops;
  
!   /* [ WORD 9-10 ]
       Symbols stored/loaded by this statement.
       ???  If we do the above and get rid of these stmts with/without
       memory ops will be the same.  Yay!  */
    bitmap GTY((skip (""))) stores;
    bitmap GTY((skip (""))) loads;
- 
-   /* [ WORD 11-12 ]
-      Temporary virtual operands for this statement.  */
-   tree vdef;
-   tree vuse;
  };
  
  
--- 363,379 ----
    /* [ WORD 1-7 ]  */
    struct gimple_statement_with_ops_base opbase;
  
!   /* [ WORD 8-9 ]
!      Temporary virtual operands for this statement.  */
!   tree vdef;
!   tree vuse;
  
!   /* [ WORD 10-11 ]
       Symbols stored/loaded by this statement.
       ???  If we do the above and get rid of these stmts with/without
       memory ops will be the same.  Yay!  */
    bitmap GTY((skip (""))) stores;
    bitmap GTY((skip (""))) loads;
  };
  
  
*************** gimple_set_use_ops (gimple g, struct use
*** 1327,1343 ****
  }
  
  
! /* Return the set of VUSE operands for statement G.  */
  
! static inline struct use_optype_d *
! gimple_vuse_ops (const_gimple g)
  {
    if (!gimple_has_mem_ops (g))
!     return NULL;
!   return g->gsmem.membase.vuse_ops;
  }
  
! 
  /* Set OPS to be the set of VUSE operands for statement G.  */
  
  static inline void
--- 1320,1341 ----
  }
  
  
! /* Return the set of VUSE operand for statement G.  */
  
! static inline use_operand_p
! gimple_vuse_op (const_gimple g)
  {
+   struct use_optype_d *ops;
    if (!gimple_has_mem_ops (g))
!     return NULL_USE_OPERAND_P;
!   ops = g->gsops.opbase.use_ops;
!   if (ops
!       && USE_OP_PTR (ops)->use == &g->gsmem.membase.vuse)
!     return USE_OP_PTR (ops);
!   return NULL_USE_OPERAND_P;
  }
  
! #if 0
  /* Set OPS to be the set of VUSE operands for statement G.  */
  
  static inline void
*************** gimple_set_vuse_ops (gimple g, struct us
*** 1346,1364 ****
    gcc_assert (gimple_has_mem_ops (g));
    g->gsmem.membase.vuse_ops = ops;
  }
  
  
! /* Return the set of VDEF operands for statement G.  */
! 
! static inline struct def_optype_d *
! gimple_vdef_ops (const_gimple g)
  {
    if (!gimple_has_mem_ops (g))
!     return NULL;
!   return g->gsmem.membase.vdef_ops;
  }
  
! 
  /* Set OPS to be the set of VDEF operands for statement G.  */
  
  static inline void
--- 1344,1367 ----
    gcc_assert (gimple_has_mem_ops (g));
    g->gsmem.membase.vuse_ops = ops;
  }
+ #endif
  
+ /* Return the set of VDEF operand for statement G.  */
  
! static inline def_operand_p
! gimple_vdef_op (const_gimple g)
  {
+   struct def_optype_d *ops;
    if (!gimple_has_mem_ops (g))
!     return NULL_DEF_OPERAND_P;
!   ops = g->gsops.opbase.def_ops;
!   if (ops
!       && DEF_OP_PTR (ops) == &g->gsmem.membase.vdef)
!     return DEF_OP_PTR (ops);
!   return NULL_DEF_OPERAND_P;
  }
  
! #if 0
  /* Set OPS to be the set of VDEF operands for statement G.  */
  
  static inline void
*************** gimple_set_vdef_ops (gimple g, struct de
*** 1367,1372 ****
--- 1370,1376 ----
    gcc_assert (gimple_has_mem_ops (g));
    g->gsmem.membase.vdef_ops = ops;
  }
+ #endif
  
  
  /* Return the single VUSE operand of the statement G.  */
Index: alias-improvements/gcc/lambda-code.c
===================================================================
*** alias-improvements.orig/gcc/lambda-code.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/lambda-code.c	2009-01-17 21:54:38.000000000 +0100
*************** can_put_in_inner_loop (struct loop *inne
*** 2142,2148 ****
    use_operand_p use_p;
    
    gcc_assert (is_gimple_assign (stmt));
!   if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS)
        || !stmt_invariant_in_loop_p (inner, stmt))
      return false;
    
--- 2142,2148 ----
    use_operand_p use_p;
    
    gcc_assert (is_gimple_assign (stmt));
!   if (gimple_vuse (stmt)
        || !stmt_invariant_in_loop_p (inner, stmt))
      return false;
    
*************** can_put_after_inner_loop (struct loop *l
*** 2167,2173 ****
    imm_use_iterator imm_iter;
    use_operand_p use_p;
  
!   if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
      return false;
    
    FOR_EACH_IMM_USE_FAST (use_p, imm_iter, gimple_assign_lhs (stmt))
--- 2167,2173 ----
    imm_use_iterator imm_iter;
    use_operand_p use_p;
  
!   if (gimple_vuse (stmt))
      return false;
    
    FOR_EACH_IMM_USE_FAST (use_p, imm_iter, gimple_assign_lhs (stmt))
*************** perfect_nestify (struct loop *loop,
*** 2535,2542 ****
  		 incremented when we do.  */
  	      for (bsi = gsi_start_bb (bbs[i]); !gsi_end_p (bsi);)
  		{ 
- 		  ssa_op_iter i;
- 		  tree n;
  		  gimple stmt = gsi_stmt (bsi);
  		  
  		  if (stmt == exit_condition
--- 2535,2540 ----
*************** perfect_nestify (struct loop *loop,
*** 2552,2563 ****
  		     VEC_index (tree, lbounds, 0), replacements, &firstbsi);
  
  		  gsi_move_before (&bsi, &tobsi);
! 		  
  		  /* If the statement has any virtual operands, they may
  		     need to be rewired because the original loop may
  		     still reference them.  */
! 		  FOR_EACH_SSA_TREE_OPERAND (n, stmt, i, SSA_OP_ALL_VIRTUALS)
! 		    mark_sym_for_renaming (SSA_NAME_VAR (n));
  		}
  	    }
  	  
--- 2550,2561 ----
  		     VEC_index (tree, lbounds, 0), replacements, &firstbsi);
  
  		  gsi_move_before (&bsi, &tobsi);
! 
  		  /* If the statement has any virtual operands, they may
  		     need to be rewired because the original loop may
  		     still reference them.  */
! 		  if (gimple_vuse (stmt))
! 		    mark_sym_for_renaming (gimple_vop (cfun));
  		}
  	    }
  	  
Index: alias-improvements/gcc/tree-complex.c
===================================================================
*** alias-improvements.orig/gcc/tree-complex.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/tree-complex.c	2009-01-17 21:54:38.000000000 +0100
*************** update_phi_components (basic_block bb)
*** 745,767 ****
      }
  }
  
- /* Mark each virtual op in STMT for ssa update.  */
- 
- static void
- update_all_vops (gimple stmt)
- {
-   ssa_op_iter iter;
-   tree sym;
- 
-   FOR_EACH_SSA_TREE_OPERAND (sym, stmt, iter, SSA_OP_ALL_VIRTUALS)
-     {
-       if (TREE_CODE (sym) == SSA_NAME)
- 	sym = SSA_NAME_VAR (sym);
-       mark_sym_for_renaming (sym);
-     }
- }
- 
- 
  /* Expand a complex move to scalars.  */
  
  static void
--- 745,750 ----
*************** expand_complex_move (gimple_stmt_iterato
*** 817,823 ****
  	}
        else
  	{
- 	  update_all_vops (stmt);
  	  if (gimple_assign_rhs_code (stmt) != COMPLEX_EXPR)
  	    {
  	      r = extract_component (gsi, rhs, 0, true);
--- 800,805 ----
*************** expand_complex_move (gimple_stmt_iterato
*** 860,866 ****
  	  gimple_return_set_retval (stmt, lhs);
  	}
  
-       update_all_vops (stmt);
        update_stmt (stmt);
      }
  }
--- 842,847 ----
Index: alias-improvements/gcc/tree-data-ref.c
===================================================================
*** alias-improvements.orig/gcc/tree-data-ref.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/tree-data-ref.c	2009-01-17 21:54:38.000000000 +0100
*************** get_references_in_stmt (gimple stmt, VEC
*** 4016,4022 ****
  	  && gimple_asm_volatile_p (stmt)))
      clobbers_memory = true;
  
!   if (ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
      return clobbers_memory;
  
    if (stmt_code == GIMPLE_ASSIGN)
--- 4016,4022 ----
  	  && gimple_asm_volatile_p (stmt)))
      clobbers_memory = true;
  
!   if (!gimple_vuse (stmt))
      return clobbers_memory;
  
    if (stmt_code == GIMPLE_ASSIGN)
*************** stores_from_loop (struct loop *loop, VEC
*** 4896,4902 ****
        gimple_stmt_iterator bsi;
  
        for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
! 	if (!ZERO_SSA_OPERANDS (gsi_stmt (bsi), SSA_OP_VDEF))
  	  VEC_safe_push (gimple, heap, *stmts, gsi_stmt (bsi));
      }
  
--- 4896,4902 ----
        gimple_stmt_iterator bsi;
  
        for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
! 	if (gimple_vdef (gsi_stmt (bsi)))
  	  VEC_safe_push (gimple, heap, *stmts, gsi_stmt (bsi));
      }
  
Index: alias-improvements/gcc/tree-dfa.c
===================================================================
*** alias-improvements.orig/gcc/tree-dfa.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/tree-dfa.c	2009-01-17 21:54:38.000000000 +0100
*************** collect_dfa_stats (struct dfa_stats_d *d
*** 464,471 ****
  	  gimple stmt = gsi_stmt (si);
  	  dfa_stats_p->num_defs += NUM_SSA_OPERANDS (stmt, SSA_OP_DEF);
  	  dfa_stats_p->num_uses += NUM_SSA_OPERANDS (stmt, SSA_OP_USE);
! 	  dfa_stats_p->num_vdefs += NUM_SSA_OPERANDS (stmt, SSA_OP_VDEF);
! 	  dfa_stats_p->num_vuses += NUM_SSA_OPERANDS (stmt, SSA_OP_VUSE);
  	}
      }
  }
--- 464,471 ----
  	  gimple stmt = gsi_stmt (si);
  	  dfa_stats_p->num_defs += NUM_SSA_OPERANDS (stmt, SSA_OP_DEF);
  	  dfa_stats_p->num_uses += NUM_SSA_OPERANDS (stmt, SSA_OP_USE);
! 	  dfa_stats_p->num_vdefs += gimple_vdef (stmt) ? 1 : 0;
! 	  dfa_stats_p->num_vuses += gimple_vuse (stmt) ? 1 : 0;
  	}
      }
  }
Index: alias-improvements/gcc/tree-flow-inline.h
===================================================================
*** alias-improvements.orig/gcc/tree-flow-inline.h	2009-01-17 21:54:37.000000000 +0100
--- alias-improvements/gcc/tree-flow-inline.h	2009-01-17 21:54:38.000000000 +0100
*************** op_iter_next_use (ssa_op_iter *ptr)
*** 658,669 ****
        ptr->uses = ptr->uses->next;
        return use_p;
      }
-   if (ptr->vuses)
-     {
-       use_p = USE_OP_PTR (ptr->vuses);
-       ptr->vuses = ptr->vuses->next;
-       return use_p;
-     }
    if (ptr->phi_i < ptr->num_phi)
      {
        return PHI_ARG_DEF_PTR (ptr->phi_stmt, (ptr->phi_i)++);
--- 658,663 ----
*************** op_iter_next_def (ssa_op_iter *ptr)
*** 686,697 ****
        ptr->defs = ptr->defs->next;
        return def_p;
      }
-   if (ptr->vdefs)
-     {
-       def_p = DEF_OP_PTR (ptr->vdefs);
-       ptr->vdefs = ptr->vdefs->next;
-       return def_p;
-     }
    ptr->done = true;
    return NULL_DEF_OPERAND_P;
  }
--- 680,685 ----
*************** op_iter_next_tree (ssa_op_iter *ptr)
*** 710,733 ****
        ptr->uses = ptr->uses->next;
        return val;
      }
-   if (ptr->vuses)
-     {
-       val = USE_OP (ptr->vuses);
-       ptr->vuses = ptr->vuses->next;
-       return val;
-     }
    if (ptr->defs)
      {
        val = DEF_OP (ptr->defs);
        ptr->defs = ptr->defs->next;
        return val;
      }
-   if (ptr->vdefs)
-     {
-       val = DEF_OP (ptr->vdefs);
-       ptr->vdefs = ptr->vdefs->next;
-       return val;
-     }
  
    ptr->done = true;
    return NULL_TREE;
--- 698,709 ----
*************** clear_and_done_ssa_iter (ssa_op_iter *pt
*** 744,751 ****
  {
    ptr->defs = NULL;
    ptr->uses = NULL;
-   ptr->vuses = NULL;
-   ptr->vdefs = NULL;
    ptr->iter_type = ssa_op_iter_none;
    ptr->phi_i = 0;
    ptr->num_phi = 0;
--- 720,725 ----
*************** clear_and_done_ssa_iter (ssa_op_iter *pt
*** 757,766 ****
  static inline void
  op_iter_init (ssa_op_iter *ptr, gimple stmt, int flags)
  {
!   ptr->defs = (flags & SSA_OP_DEF) ? gimple_def_ops (stmt) : NULL;
!   ptr->uses = (flags & SSA_OP_USE) ? gimple_use_ops (stmt) : NULL;
!   ptr->vuses = (flags & SSA_OP_VUSE) ? gimple_vuse_ops (stmt) : NULL;
!   ptr->vdefs = (flags & SSA_OP_VDEF) ? gimple_vdef_ops (stmt) : NULL;
    ptr->done = false;
  
    ptr->phi_i = 0;
--- 731,750 ----
  static inline void
  op_iter_init (ssa_op_iter *ptr, gimple stmt, int flags)
  {
!   /* We do not support iterating over virtual defs or uses without
!      iterating over defs or uses at the same time.  */
!   gcc_assert ((!(flags & SSA_OP_VDEF) || (flags & SSA_OP_DEF))
! 	      && (!(flags & SSA_OP_VUSE) || (flags & SSA_OP_USE)));
!   ptr->defs = (flags & (SSA_OP_DEF|SSA_OP_VDEF)) ? gimple_def_ops (stmt) : NULL;
!   if (!(flags & SSA_OP_VDEF)
!       && ptr->defs
!       && gimple_vdef (stmt) != NULL_TREE)
!     ptr->defs = ptr->defs->next;
!   ptr->uses = (flags & (SSA_OP_USE|SSA_OP_VUSE)) ? gimple_use_ops (stmt) : NULL;
!   if (!(flags & SSA_OP_VUSE)
!       && ptr->uses
!       && gimple_vuse (stmt) != NULL_TREE)
!     ptr->uses = ptr->uses->next;
    ptr->done = false;
  
    ptr->phi_i = 0;
*************** op_iter_init (ssa_op_iter *ptr, gimple s
*** 773,779 ****
  static inline use_operand_p
  op_iter_init_use (ssa_op_iter *ptr, gimple stmt, int flags)
  {
!   gcc_assert ((flags & SSA_OP_ALL_DEFS) == 0);
    op_iter_init (ptr, stmt, flags);
    ptr->iter_type = ssa_op_iter_use;
    return op_iter_next_use (ptr);
--- 757,764 ----
  static inline use_operand_p
  op_iter_init_use (ssa_op_iter *ptr, gimple stmt, int flags)
  {
!   gcc_assert ((flags & SSA_OP_ALL_DEFS) == 0
! 	      && (flags & SSA_OP_USE));
    op_iter_init (ptr, stmt, flags);
    ptr->iter_type = ssa_op_iter_use;
    return op_iter_next_use (ptr);
*************** op_iter_init_use (ssa_op_iter *ptr, gimp
*** 784,790 ****
  static inline def_operand_p
  op_iter_init_def (ssa_op_iter *ptr, gimple stmt, int flags)
  {
!   gcc_assert ((flags & SSA_OP_ALL_USES) == 0);
    op_iter_init (ptr, stmt, flags);
    ptr->iter_type = ssa_op_iter_def;
    return op_iter_next_def (ptr);
--- 769,776 ----
  static inline def_operand_p
  op_iter_init_def (ssa_op_iter *ptr, gimple stmt, int flags)
  {
!   gcc_assert ((flags & SSA_OP_ALL_USES) == 0
! 	      && (flags & SSA_OP_DEF));
    op_iter_init (ptr, stmt, flags);
    ptr->iter_type = ssa_op_iter_def;
    return op_iter_next_def (ptr);
*************** op_iter_init_tree (ssa_op_iter *ptr, gim
*** 800,829 ****
    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_vdef (use_operand_p *use, def_operand_p *def,
- 		   ssa_op_iter *ptr)
- {
- #ifdef ENABLE_CHECKING
-   gcc_assert (ptr->iter_type == ssa_op_iter_vdef);
- #endif
-   if (ptr->vdefs)
-     {
-       *def = DEF_OP_PTR (ptr->vdefs);
-       *use = USE_OP_PTR (ptr->vuses);
-       ptr->vdefs = ptr->vdefs->next;
-       ptr->vuses = ptr->vuses->next;
-       return;
-     }
- 
-   *def = NULL_DEF_OPERAND_P;
-   *use = NULL_USE_OPERAND_P;
-   ptr->done = true;
-   return;
- }
- 
  
  /* If there is a single operand in STMT matching FLAGS, return it.  Otherwise
     return NULL.  */
--- 786,791 ----
*************** link_use_stmts_after (use_operand_p head
*** 1060,1068 ****
      }
    else
      {
!       FOR_EACH_SSA_USE_OPERAND (use_p, head_stmt, op_iter, flag)
! 	if (USE_FROM_PTR (use_p) == use)
! 	  last_p = move_use_after_head (use_p, head, last_p);
      }
    /* Link iter node in after last_p.  */
    if (imm->iter_node.prev != NULL)
--- 1022,1038 ----
      }
    else
      {
!       if (flag == SSA_OP_USE)
! 	{
! 	  FOR_EACH_SSA_USE_OPERAND (use_p, head_stmt, op_iter, flag)
! 	    if (USE_FROM_PTR (use_p) == use)
! 	      last_p = move_use_after_head (use_p, head, last_p);
! 	}
!       else if ((use_p = gimple_vuse_op (head_stmt)) != NULL_USE_OPERAND_P)
! 	{
! 	  if (USE_FROM_PTR (use_p) == use)
! 	    last_p = move_use_after_head (use_p, head, last_p);
! 	}
      }
    /* Link iter node in after last_p.  */
    if (imm->iter_node.prev != NULL)
Index: alias-improvements/gcc/tree-into-ssa.c
===================================================================
*** alias-improvements.orig/gcc/tree-into-ssa.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/tree-into-ssa.c	2009-01-17 21:54:38.000000000 +0100
*************** rewrite_update_stmt (struct dom_walk_dat
*** 1959,1967 ****
        FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
  	maybe_replace_use (use_p);
  
!       if (need_to_update_vops_p)
! 	FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_VIRTUAL_USES)
! 	  maybe_replace_use (use_p);
      }
  
    /* Register definitions of names in NEW_SSA_NAMES and OLD_SSA_NAMES.
--- 1959,1967 ----
        FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
  	maybe_replace_use (use_p);
  
!       if (need_to_update_vops_p
! 	  && (use_p = gimple_vuse_op (stmt)) != NULL_USE_OPERAND_P)
! 	maybe_replace_use (use_p);
      }
  
    /* Register definitions of names in NEW_SSA_NAMES and OLD_SSA_NAMES.
*************** rewrite_update_stmt (struct dom_walk_dat
*** 1972,1980 ****
        FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, iter, SSA_OP_DEF)
  	maybe_register_def (def_p, stmt);
  
!       if (need_to_update_vops_p)
! 	FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, iter, SSA_OP_VIRTUAL_DEFS)
! 	  maybe_register_def (def_p, stmt);
      }
  }
  
--- 1972,1980 ----
        FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, iter, SSA_OP_DEF)
  	maybe_register_def (def_p, stmt);
  
!       if (need_to_update_vops_p
! 	  && (def_p = gimple_vdef_op (stmt)) != NULL_DEF_OPERAND_P)
! 	maybe_register_def (def_p, stmt);
      }
  }
  
Index: alias-improvements/gcc/tree-loop-distribution.c
===================================================================
*** alias-improvements.orig/gcc/tree-loop-distribution.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/tree-loop-distribution.c	2009-01-17 21:54:38.000000000 +0100
*************** static bool
*** 238,251 ****
  generate_memset_zero (gimple stmt, tree op0, tree nb_iter,
  		      gimple_stmt_iterator bsi)
  {
!   tree t, addr_base;
    tree nb_bytes = NULL;
    bool res = false;
    gimple_seq stmts = NULL, stmt_list = NULL;
    gimple fn_call;
    tree mem, fndecl, fntype, fn;
    gimple_stmt_iterator i;
-   ssa_op_iter iter;
    struct data_reference *dr = XCNEW (struct data_reference);
  
    DR_STMT (dr) = stmt;
--- 238,250 ----
  generate_memset_zero (gimple stmt, tree op0, tree nb_iter,
  		      gimple_stmt_iterator bsi)
  {
!   tree addr_base;
    tree nb_bytes = NULL;
    bool res = false;
    gimple_seq stmts = NULL, stmt_list = NULL;
    gimple fn_call;
    tree mem, fndecl, fntype, fn;
    gimple_stmt_iterator i;
    struct data_reference *dr = XCNEW (struct data_reference);
  
    DR_STMT (dr) = stmt;
*************** generate_memset_zero (gimple stmt, tree 
*** 295,323 ****
      {
        gimple s = gsi_stmt (i);
        update_stmt_if_modified (s);
- 
-       FOR_EACH_SSA_TREE_OPERAND (t, s, iter, SSA_OP_VIRTUAL_DEFS)
- 	{
- 	  if (TREE_CODE (t) == SSA_NAME)
- 	    t = SSA_NAME_VAR (t);
- 	  mark_sym_for_renaming (t);
- 	}
-     }
- 
-   /* Mark also the uses of the VDEFS of STMT to be renamed.  */
-   FOR_EACH_SSA_TREE_OPERAND (t, stmt, iter, SSA_OP_VIRTUAL_DEFS)
-     {
-       if (TREE_CODE (t) == SSA_NAME)
- 	{
- 	  gimple s;
- 	  imm_use_iterator imm_iter;
- 
- 	  FOR_EACH_IMM_USE_STMT (s, imm_iter, t)
- 	    update_stmt (s);
- 
- 	  t = SSA_NAME_VAR (t);
- 	}
-       mark_sym_for_renaming (t);
      }
  
    gsi_insert_seq_after (&bsi, stmt_list, GSI_CONTINUE_LINKING);
--- 294,299 ----
*************** static void
*** 594,600 ****
  rdg_flag_uses (struct graph *rdg, int u, bitmap partition, bitmap loops,
  	       bitmap processed, bool *part_has_writes)
  {
-   ssa_op_iter iter;
    use_operand_p use_p;
    struct vertex *x = &(rdg->vertices[u]);
    gimple stmt = RDGV_STMT (x);
--- 570,575 ----
*************** rdg_flag_uses (struct graph *rdg, int u,
*** 614,620 ****
  
    if (gimple_code (stmt) != GIMPLE_PHI)
      {
!       FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_VIRTUAL_USES)
  	{
  	  tree use = USE_FROM_PTR (use_p);
  
--- 589,595 ----
  
    if (gimple_code (stmt) != GIMPLE_PHI)
      {
!       if ((use_p = gimple_vuse_op (stmt)) != NULL_USE_OPERAND_P)
  	{
  	  tree use = USE_FROM_PTR (use_p);
  
Index: alias-improvements/gcc/tree-predcom.c
===================================================================
*** alias-improvements.orig/gcc/tree-predcom.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/tree-predcom.c	2009-01-17 21:54:38.000000000 +0100
*************** get_init_expr (chain_p chain, unsigned i
*** 1423,1429 ****
  void
  mark_virtual_ops_for_renaming (gimple stmt)
  {
-   ssa_op_iter iter;
    tree var;
  
    if (gimple_code (stmt) == GIMPLE_PHI)
--- 1423,1428 ----
*************** mark_virtual_ops_for_renaming (gimple st
*** 1439,1462 ****
      }
  
    update_stmt (stmt);
! 
!   FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_ALL_VIRTUALS)
!     {
!       if (TREE_CODE (var) == SSA_NAME)
! 	var = SSA_NAME_VAR (var);
!       mark_sym_for_renaming (var);
!     }
! }
! 
! /* Calls mark_virtual_ops_for_renaming for all members of LIST.  */
! 
! static void
! mark_virtual_ops_for_renaming_list (gimple_seq list)
! {
!   gimple_stmt_iterator gsi;
! 
!   for (gsi = gsi_start (list); !gsi_end_p (gsi); gsi_next (&gsi))
!     mark_virtual_ops_for_renaming (gsi_stmt (gsi));
  }
  
  /* Returns a new temporary variable used for the I-th variable carrying
--- 1438,1445 ----
      }
  
    update_stmt (stmt);
!   if (gimple_vuse (stmt))
!     mark_sym_for_renaming (gimple_vop (cfun));
  }
  
  /* Returns a new temporary variable used for the I-th variable carrying
*************** initialize_root_vars (struct loop *loop,
*** 1525,1534 ****
  
        init = force_gimple_operand (init, &stmts, true, NULL_TREE);
        if (stmts)
! 	{
! 	  mark_virtual_ops_for_renaming_list (stmts);
! 	  gsi_insert_seq_on_edge_immediate (entry, stmts);
! 	}
  
        phi = create_phi_node (var, loop->header);
        SSA_NAME_DEF_STMT (var) = phi;
--- 1508,1514 ----
  
        init = force_gimple_operand (init, &stmts, true, NULL_TREE);
        if (stmts)
! 	gsi_insert_seq_on_edge_immediate (entry, stmts);
  
        phi = create_phi_node (var, loop->header);
        SSA_NAME_DEF_STMT (var) = phi;
*************** initialize_root_vars_lm (struct loop *lo
*** 1589,1598 ****
        
    init = force_gimple_operand (init, &stmts, written, NULL_TREE);
    if (stmts)
!     {
!       mark_virtual_ops_for_renaming_list (stmts);
!       gsi_insert_seq_on_edge_immediate (entry, stmts);
!     }
  
    if (written)
      {
--- 1569,1575 ----
        
    init = force_gimple_operand (init, &stmts, written, NULL_TREE);
    if (stmts)
!     gsi_insert_seq_on_edge_immediate (entry, stmts);
  
    if (written)
      {
*************** prepare_initializers_chain (struct loop 
*** 2466,2475 ****
  
        init = force_gimple_operand (init, &stmts, false, NULL_TREE);
        if (stmts)
! 	{
! 	  mark_virtual_ops_for_renaming_list (stmts);
! 	  gsi_insert_seq_on_edge_immediate (entry, stmts);
! 	}
  
        VEC_replace (tree, chain->inits, i, init);
      }
--- 2443,2449 ----
  
        init = force_gimple_operand (init, &stmts, false, NULL_TREE);
        if (stmts)
! 	gsi_insert_seq_on_edge_immediate (entry, stmts);
  
        VEC_replace (tree, chain->inits, i, init);
      }
Index: alias-improvements/gcc/tree-sra.c
===================================================================
*** alias-improvements.orig/gcc/tree-sra.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/tree-sra.c	2009-01-17 23:04:22.000000000 +0100
*************** extern void debug_sra_elt_name (struct s
*** 210,216 ****
  static tree generate_element_ref (struct sra_elt *);
  static gimple_seq sra_build_assignment (tree dst, tree src);
  static void mark_all_v_defs_seq (gimple_seq);
- static void mark_all_v_defs_stmt (gimple);
  
  
  /* Return true if DECL is an SRA candidate.  */
--- 210,215 ----
*************** decide_instantiations (void)
*** 2014,2040 ****
  
  /* Phase Four: Update the function to match the replacements created.  */
  
- /* Mark all the variables in VDEF/VUSE operators for STMT for
-    renaming. This becomes necessary when we modify all of a
-    non-scalar.  */
- 
- static void
- mark_all_v_defs_stmt (gimple stmt)
- {
-   tree sym;
-   ssa_op_iter iter;
- 
-   update_stmt_if_modified (stmt);
- 
-   FOR_EACH_SSA_TREE_OPERAND (sym, stmt, iter, SSA_OP_ALL_VIRTUALS)
-     {
-       if (TREE_CODE (sym) == SSA_NAME)
- 	sym = SSA_NAME_VAR (sym);
-       mark_sym_for_renaming (sym);
-     }
- }
- 
- 
  /* Mark all the variables in virtual operands in all the statements in
     LIST for renaming.  */
  
--- 2013,2018 ----
*************** mark_all_v_defs_seq (gimple_seq seq)
*** 2044,2050 ****
    gimple_stmt_iterator gsi;
  
    for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
!     mark_all_v_defs_stmt (gsi_stmt (gsi));
  }
  
  /* Mark every replacement under ELT with TREE_NO_WARNING.  */
--- 2022,2028 ----
    gimple_stmt_iterator gsi;
  
    for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
!     update_stmt_if_modified (gsi_stmt (gsi));
  }
  
  /* Mark every replacement under ELT with TREE_NO_WARNING.  */
*************** static void
*** 2869,2874 ****
--- 2847,2853 ----
  sra_replace (gimple_stmt_iterator *gsi, gimple_seq seq)
  {
    sra_insert_before (gsi, seq);
+   unlink_stmt_vdef (gsi_stmt (*gsi));
    gsi_remove (gsi, false);
    if (gsi_end_p (*gsi))
      *gsi = gsi_last (gsi_seq (*gsi));
*************** scalarize_use (struct sra_elt *elt, tree
*** 3144,3150 ****
  	  replacement = tmp;
  	}
        if (is_output)
! 	  mark_all_v_defs_stmt (stmt);
        *expr_p = REPLDUP (replacement);
        update_stmt (stmt);
      }
--- 3123,3129 ----
  	  replacement = tmp;
  	}
        if (is_output)
! 	  update_stmt_if_modified (stmt);
        *expr_p = REPLDUP (replacement);
        update_stmt (stmt);
      }
*************** scalarize_copy (struct sra_elt *lhs_elt,
*** 3364,3370 ****
  	 original block copy statement.  */
  
        stmt = gsi_stmt (*gsi);
!       mark_all_v_defs_stmt (stmt);
  
        seq = NULL;
        generate_element_copy (lhs_elt, rhs_elt, &seq);
--- 3343,3349 ----
  	 original block copy statement.  */
  
        stmt = gsi_stmt (*gsi);
!       update_stmt_if_modified (stmt);
  
        seq = NULL;
        generate_element_copy (lhs_elt, rhs_elt, &seq);
*************** scalarize_init (struct sra_elt *lhs_elt,
*** 3431,3437 ****
        /* The LHS is fully instantiated.  The list of initializations
  	 replaces the original structure assignment.  */
        gcc_assert (seq);
!       mark_all_v_defs_stmt (gsi_stmt (*gsi));
        mark_all_v_defs_seq (seq);
        sra_replace (gsi, seq);
      }
--- 3410,3416 ----
        /* The LHS is fully instantiated.  The list of initializations
  	 replaces the original structure assignment.  */
        gcc_assert (seq);
!       update_stmt_if_modified (gsi_stmt (*gsi));
        mark_all_v_defs_seq (seq);
        sra_replace (gsi, seq);
      }
*************** scalarize_ldst (struct sra_elt *elt, tre
*** 3482,3488 ****
        gimple_seq seq = NULL;
        gimple stmt = gsi_stmt (*gsi);
  
!       mark_all_v_defs_stmt (stmt);
        generate_copy_inout (elt, is_output, other, &seq);
        gcc_assert (seq);
        mark_all_v_defs_seq (seq);
--- 3461,3467 ----
        gimple_seq seq = NULL;
        gimple stmt = gsi_stmt (*gsi);
  
!       update_stmt_if_modified (stmt);
        generate_copy_inout (elt, is_output, other, &seq);
        gcc_assert (seq);
        mark_all_v_defs_seq (seq);
Index: alias-improvements/gcc/tree-ssa-ccp.c
===================================================================
*** alias-improvements.orig/gcc/tree-ssa-ccp.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/tree-ssa-ccp.c	2009-01-17 21:54:38.000000000 +0100
*************** surely_varying_stmt_p (gimple stmt)
*** 598,604 ****
      }
  
    /* Any other store operation is not interesting.  */
!   else if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_VIRTUAL_DEFS))
      return true;
  
    /* Anything other than assignments and conditional jumps are not
--- 598,604 ----
      }
  
    /* Any other store operation is not interesting.  */
!   else if (gimple_vdef (stmt))
      return true;
  
    /* Anything other than assignments and conditional jumps are not
*************** gimplify_and_update_call_from_tree (gimp
*** 3166,3172 ****
    else
      {
        new_stmt = gimple_build_assign (lhs, tmp);
-       copy_virtual_operands (new_stmt, stmt);
        move_ssa_defining_stmt_for_defs (new_stmt, stmt);
      }
  
--- 3166,3171 ----
Index: alias-improvements/gcc/tree-ssa-coalesce.c
===================================================================
*** alias-improvements.orig/gcc/tree-ssa-coalesce.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/tree-ssa-coalesce.c	2009-01-17 21:54:38.000000000 +0100
*************** create_outofssa_var_map (coalesce_list_p
*** 1114,1126 ****
  	  FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, (SSA_OP_DEF|SSA_OP_USE))
  	    bitmap_set_bit (used_in_real_ops, DECL_UID (SSA_NAME_VAR (var)));
  
! 	  /* Validate that virtual ops don't get used in funny ways.  */
! 	  FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_ALL_VIRTUALS)
! 	    {
! 	      bitmap_set_bit (used_in_virtual_ops, 
! 			      DECL_UID (SSA_NAME_VAR (var)));
! 	    }
! 
  #endif /* ENABLE_CHECKING */
  	}
      }
--- 1114,1124 ----
  	  FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, (SSA_OP_DEF|SSA_OP_USE))
  	    bitmap_set_bit (used_in_real_ops, DECL_UID (SSA_NAME_VAR (var)));
  
! 	  /* Validate that virtual ops don't get used in funny ways.
! 	     ???  This verifying is now quite useless.  Checking that
! 	     the gimple VOP is not used in a real operand would be enough.  */
! 	  bitmap_set_bit (used_in_virtual_ops, 
! 			  DECL_UID (gimple_vop (cfun)));
  #endif /* ENABLE_CHECKING */
  	}
      }
Index: alias-improvements/gcc/tree-ssa-copy.c
===================================================================
*** alias-improvements.orig/gcc/tree-ssa-copy.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/tree-ssa-copy.c	2009-01-17 21:54:38.000000000 +0100
*************** propagate_tree_value_into_stmt (gimple_s
*** 363,370 ****
  
        tree expr = NULL_TREE;
        propagate_tree_value (&expr, val);
!       new_stmt  = gimple_build_assign (gimple_call_lhs (stmt), expr);
!       copy_virtual_operands (new_stmt, stmt);
        move_ssa_defining_stmt_for_defs (new_stmt, stmt);
        gsi_replace (gsi, new_stmt, false);
      }
--- 363,369 ----
  
        tree expr = NULL_TREE;
        propagate_tree_value (&expr, val);
!       new_stmt = gimple_build_assign (gimple_call_lhs (stmt), expr);
        move_ssa_defining_stmt_for_defs (new_stmt, stmt);
        gsi_replace (gsi, new_stmt, false);
      }
*************** stmt_may_generate_copy (gimple stmt)
*** 412,418 ****
      return false;
  
    /* Statements with loads and/or stores will never generate a useful copy.  */
!   if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
      return false;
  
    /* Otherwise, the only statements that generate useful copies are
--- 411,417 ----
      return false;
  
    /* Statements with loads and/or stores will never generate a useful copy.  */
!   if (gimple_vuse (stmt))
      return false;
  
    /* Otherwise, the only statements that generate useful copies are
Index: alias-improvements/gcc/tree-ssa-dom.c
===================================================================
*** alias-improvements.orig/gcc/tree-ssa-dom.c	2009-01-17 21:54:37.000000000 +0100
--- alias-improvements/gcc/tree-ssa-dom.c	2009-01-17 21:54:38.000000000 +0100
*************** eliminate_redundant_computations (gimple
*** 1841,1847 ****
    if (! def
        || TREE_CODE (def) != SSA_NAME
        || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def)
!       || !ZERO_SSA_OPERANDS (stmt, SSA_OP_VDEF)
        /* Do not record equivalences for increments of ivs.  This would create
  	 overlapping live ranges for a very questionable gain.  */
        || simple_iv_increment_p (stmt))
--- 1841,1847 ----
    if (! def
        || TREE_CODE (def) != SSA_NAME
        || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def)
!       || gimple_vdef (stmt)
        /* Do not record equivalences for increments of ivs.  This would create
  	 overlapping live ranges for a very questionable gain.  */
        || simple_iv_increment_p (stmt))
Index: alias-improvements/gcc/tree-ssa-dse.c
===================================================================
*** alias-improvements.orig/gcc/tree-ssa-dse.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/tree-ssa-dse.c	2009-01-17 21:54:38.000000000 +0100
*************** dse_optimize_stmt (struct dom_walk_data 
*** 256,262 ****
  
    /* If this statement has no virtual defs, then there is nothing
       to do.  */
!   if (ZERO_SSA_OPERANDS (stmt, SSA_OP_VDEF))
      return;
  
    /* We know we have virtual definitions.  If this is a GIMPLE_ASSIGN
--- 256,262 ----
  
    /* If this statement has no virtual defs, then there is nothing
       to do.  */
!   if (!gimple_vdef (stmt))
      return;
  
    /* We know we have virtual definitions.  If this is a GIMPLE_ASSIGN
Index: alias-improvements/gcc/tree-ssa-ifcombine.c
===================================================================
*** alias-improvements.orig/gcc/tree-ssa-ifcombine.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/tree-ssa-ifcombine.c	2009-01-17 21:54:38.000000000 +0100
*************** bb_no_side_effects_p (basic_block bb)
*** 108,114 ****
        gimple stmt = gsi_stmt (gsi);
  
        if (gimple_has_volatile_ops (stmt)
! 	  || !ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
  	return false;
      }
  
--- 108,114 ----
        gimple stmt = gsi_stmt (gsi);
  
        if (gimple_has_volatile_ops (stmt)
! 	  || gimple_vuse (stmt))
  	return false;
      }
  
Index: alias-improvements/gcc/tree-ssa-loop-im.c
===================================================================
*** alias-improvements.orig/gcc/tree-ssa-loop-im.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/tree-ssa-loop-im.c	2009-01-17 21:54:38.000000000 +0100
*************** movement_possibility (gimple stmt)
*** 362,368 ****
    if (gimple_get_lhs (stmt) == NULL_TREE)
      return MOVE_IMPOSSIBLE;
  
!   if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_VIRTUAL_DEFS))
      return MOVE_IMPOSSIBLE;
  
    if (stmt_ends_bb_p (stmt)
--- 362,368 ----
    if (gimple_get_lhs (stmt) == NULL_TREE)
      return MOVE_IMPOSSIBLE;
  
!   if (gimple_vdef (stmt))
      return MOVE_IMPOSSIBLE;
  
    if (stmt_ends_bb_p (stmt)
*************** determine_max_movement (gimple stmt, boo
*** 681,687 ****
      if (!add_dependency (val, lim_data, loop, true))
        return false;
  
!   if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_VIRTUAL_USES))
      {
        mem_ref_p ref = mem_ref_in_stmt (stmt);
  
--- 681,687 ----
      if (!add_dependency (val, lim_data, loop, true))
        return false;
  
!   if (gimple_vuse (stmt))
      {
        mem_ref_p ref = mem_ref_in_stmt (stmt);
  
*************** determine_max_movement (gimple stmt, boo
*** 694,700 ****
  	}
        else
  	{
! 	  FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter, SSA_OP_VIRTUAL_USES)
  	    {
  	      if (!add_dependency (val, lim_data, loop, false))
  		return false;
--- 694,700 ----
  	}
        else
  	{
! 	  if ((val = gimple_vuse (stmt)) != NULL_TREE)
  	    {
  	      if (!add_dependency (val, lim_data, loop, false))
  		return false;
*************** gather_mem_refs_stmt (struct loop *loop,
*** 1309,1321 ****
    hashval_t hash;
    PTR *slot;
    mem_ref_p ref;
-   ssa_op_iter oi;
    tree vname;
    bool is_stored;
    bitmap clvops;
    unsigned id;
  
!   if (ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
      return;
  
    mem = simple_mem_ref_in_stmt (stmt, &is_stored);
--- 1309,1320 ----
    hashval_t hash;
    PTR *slot;
    mem_ref_p ref;
    tree vname;
    bool is_stored;
    bitmap clvops;
    unsigned id;
  
!   if (!gimple_vuse (stmt))
      return;
  
    mem = simple_mem_ref_in_stmt (stmt, &is_stored);
*************** gather_mem_refs_stmt (struct loop *loop,
*** 1347,1360 ****
    if (is_stored)
      mark_ref_stored (ref, loop);
  
!   FOR_EACH_SSA_TREE_OPERAND (vname, stmt, oi, SSA_OP_VIRTUAL_USES)
      bitmap_set_bit (ref->vops, DECL_UID (SSA_NAME_VAR (vname)));
    record_mem_ref_loc (ref, loop, stmt, mem);
    return;
  
  fail:
    clvops = VEC_index (bitmap, memory_accesses.clobbered_vops, loop->num);
!   FOR_EACH_SSA_TREE_OPERAND (vname, stmt, oi, SSA_OP_VIRTUAL_USES)
      bitmap_set_bit (clvops, DECL_UID (SSA_NAME_VAR (vname)));
  }
  
--- 1346,1359 ----
    if (is_stored)
      mark_ref_stored (ref, loop);
  
!   if ((vname = gimple_vuse (stmt)) != NULL_TREE)
      bitmap_set_bit (ref->vops, DECL_UID (SSA_NAME_VAR (vname)));
    record_mem_ref_loc (ref, loop, stmt, mem);
    return;
  
  fail:
    clvops = VEC_index (bitmap, memory_accesses.clobbered_vops, loop->num);
!   if ((vname = gimple_vuse (stmt)) != NULL_TREE)
      bitmap_set_bit (clvops, DECL_UID (SSA_NAME_VAR (vname)));
  }
  
Index: alias-improvements/gcc/tree-ssa-loop-ivcanon.c
===================================================================
*** alias-improvements.orig/gcc/tree-ssa-loop-ivcanon.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/tree-ssa-loop-ivcanon.c	2009-01-17 21:54:38.000000000 +0100
*************** empty_loop_p (struct loop *loop)
*** 442,448 ****
  	{
  	  gimple stmt = gsi_stmt (gsi);
  
! 	  if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_VIRTUAL_DEFS)
  	      || gimple_has_volatile_ops (stmt))
  	    {
  	      free (body);
--- 442,448 ----
  	{
  	  gimple stmt = gsi_stmt (gsi);
  
! 	  if (gimple_vdef (stmt)
  	      || gimple_has_volatile_ops (stmt))
  	    {
  	      free (body);
Index: alias-improvements/gcc/tree-ssa-loop-prefetch.c
===================================================================
*** alias-improvements.orig/gcc/tree-ssa-loop-prefetch.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/tree-ssa-loop-prefetch.c	2009-01-17 21:54:38.000000000 +0100
*************** gather_memory_references (struct loop *l
*** 501,507 ****
  
  	  if (gimple_code (stmt) != GIMPLE_ASSIGN)
  	    {
! 	      if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS)
  		  || (is_gimple_call (stmt)
  		      && !(gimple_call_flags (stmt) & ECF_CONST)))
  		*no_other_refs = false;
--- 501,507 ----
  
  	  if (gimple_code (stmt) != GIMPLE_ASSIGN)
  	    {
! 	      if (gimple_vuse (stmt)
  		  || (is_gimple_call (stmt)
  		      && !(gimple_call_flags (stmt) & ECF_CONST)))
  		*no_other_refs = false;
Index: alias-improvements/gcc/tree-ssa-operands.c
===================================================================
*** alias-improvements.orig/gcc/tree-ssa-operands.c	2009-01-17 21:54:37.000000000 +0100
--- alias-improvements/gcc/tree-ssa-operands.c	2009-01-17 23:10:29.000000000 +0100
*************** finalize_ssa_defs (gimple stmt)
*** 545,550 ****
--- 545,561 ----
    /* There should only be a single real definition per assignment.  */
    gcc_assert ((stmt && gimple_code (stmt) != GIMPLE_ASSIGN) || num <= 1);
  
+   /* Set the symbols referenced by STMT.  */
+   if (gimple_has_mem_ops (stmt))
+     gimple_set_stored_syms (stmt, build_stores, &operands_bitmap_obstack);
+ 
+   /* Pre-pend the vdef we may have built.  */
+   if (VEC_length (tree, build_vdefs) == 1)
+     {
+       VEC_safe_insert (tree, heap, build_defs, 0, (tree)gimple_vdef_ptr (stmt));
+       ++num;
+     }
+ 
    new_list.next = NULL;
    last = &new_list;
  
*************** finalize_ssa_defs (gimple stmt)
*** 560,565 ****
--- 571,581 ----
    /* If there is anything in the old list, free it.  */
    if (old_ops)
      {
+       if (gimple_vdef (stmt))
+ 	{
+ 	  unlink_stmt_vdef (stmt);
+ 	  gimple_set_vdef (stmt, NULL_TREE);
+ 	}
        old_ops->next = gimple_ssa_operands (cfun)->free_defs;
        gimple_ssa_operands (cfun)->free_defs = old_ops;
      }
*************** finalize_ssa_defs (gimple stmt)
*** 567,586 ****
    /* If there is anything remaining in the build_defs list, simply emit it.  */
    for ( ; new_i < num; new_i++)
      last = add_def_op ((tree *) VEC_index (tree, build_defs, new_i), last);
  
    /* Now set the stmt's operands.  */
    gimple_set_def_ops (stmt, new_list.next);
- 
- #ifdef ENABLE_CHECKING
-   {
-     def_optype_p ptr;
-     unsigned x = 0;
-     for (ptr = gimple_def_ops (stmt); ptr; ptr = ptr->next)
-       x++;
- 
-     gcc_assert (x == num);
-   }
- #endif
  }
  
  
--- 583,596 ----
    /* If there is anything remaining in the build_defs list, simply emit it.  */
    for ( ; new_i < num; new_i++)
      last = add_def_op ((tree *) VEC_index (tree, build_defs, new_i), last);
+   if (VEC_length (tree, build_vdefs) == 1)
+     {
+       gimple_set_vdef (stmt, gimple_vop (cfun));
+       mark_sym_for_renaming (gimple_vop (cfun));
+     }
  
    /* Now set the stmt's operands.  */
    gimple_set_def_ops (stmt, new_list.next);
  }
  
  
*************** finalize_ssa_uses (gimple stmt)
*** 594,604 ****
--- 604,647 ----
    struct use_optype_d new_list;
    use_optype_p old_ops, ptr, last;
  
+   /* Set the symbols referenced by STMT.  */
+   if (gimple_has_mem_ops (stmt))
+     gimple_set_loaded_syms (stmt, build_loads, &operands_bitmap_obstack);
+ 
+   /* Add a may-use if we have a VDEF but no VUSE.  */
+   if (VEC_length (tree, build_vuses) == 0
+       && VEC_length (tree, build_vdefs) == 1)
+     VEC_safe_push (tree, heap, build_vuses, gimple_vop (cfun));
+ 
    new_list.next = NULL;
    last = &new_list;
  
    old_ops = gimple_use_ops (stmt);
  
+   if (gimple_vuse (stmt))
+     {
+       /* If there is a VUSE on the old list and we want to add a new one,
+ 	 move it over.  Else clear the operand.  */
+       if (VEC_length (tree, build_vuses) == 1)
+ 	{
+ 	  last->next = old_ops;
+ 	  old_ops = old_ops->next;
+ 	  last = last->next;
+ 	  last->next = NULL;
+ 	  set_virtual_use_link (USE_OP_PTR (last), stmt);
+ 	}
+       else
+ 	gimple_set_vuse (stmt, NULL_TREE);
+     }
+   else if (VEC_length (tree, build_vuses) == 1)
+     {
+       /* If we want to add a VUSE, set the operand and prepend it to
+          the list of to build uses.  */
+       gimple_set_vuse (stmt, gimple_vop (cfun));
+       VEC_safe_insert (tree, heap, build_uses, 0, (tree)gimple_vuse_ptr (stmt));
+       mark_sym_for_renaming (gimple_vop (cfun));
+     }
+ 
    /* If there is anything in the old list, free it.  */
    if (old_ops)
      {
*************** finalize_ssa_uses (gimple stmt)
*** 616,772 ****
  
    /* Now set the stmt's operands.  */
    gimple_set_use_ops (stmt, new_list.next);
- 
- #ifdef ENABLE_CHECKING
-   {
-     unsigned x = 0;
-     for (ptr = gimple_use_ops (stmt); ptr; ptr = ptr->next)
-       x++;
- 
-     gcc_assert (x == VEC_length (tree, build_uses));
-   }
- #endif
- }
- 
- 
- /* Takes elements from BUILD_VDEFS and turns them into vdef operands of
-    STMT.  */
- 
- static inline void
- finalize_ssa_vdefs (gimple stmt)
- {
-   def_optype_p old_ops = gimple_vdef_ops (stmt);
- 
-   gcc_assert (VEC_length (tree, build_vdefs) <= 1);
- 
-   gcc_assert ((!old_ops && !gimple_vdef (stmt))
- 	      || (old_ops && gimple_vdef (stmt)));
- 
-   /* Set the symbols referenced by STMT.  */
-   gimple_set_stored_syms (stmt, build_stores, &operands_bitmap_obstack);
- 
-   /* If nothing changed, fine.  */
-   if (VEC_length (tree, build_vdefs) == (old_ops ? 1 : 0))
-     {
-       return;
-     }
- 
-   /* Add a VDEF and mark the gimple VOP for renaming.  */
-   if (VEC_length (tree, build_vdefs) == 1)
-     {
-       struct def_optype_d new_list;
-       gimple_set_vdef (stmt, VEC_index (tree, build_vdefs, 0));
-       new_list.next = NULL;
-       add_def_op (gimple_vdef_ptr (stmt), &new_list);
-       gimple_set_vdef_ops (stmt, new_list.next);
-       mark_sym_for_renaming (gimple_vop (cfun));
-     }
- 
-   /* Remove the VDEF.  */
-   else
-     {
-       unlink_stmt_vdef (stmt);
-       old_ops->next = gimple_ssa_operands (cfun)->free_defs;
-       gimple_ssa_operands (cfun)->free_defs = old_ops;
-       gimple_set_vdef_ops (stmt, NULL);
-       gimple_set_vdef (stmt, NULL_TREE);
-     }
- }
- 
- 
- /* Takes elements from BUILD_VUSES and turns them into VUSE operands of
-    STMT.  */
- 
- static inline void
- finalize_ssa_vuse_ops (gimple stmt)
- {
-   use_optype_p old_ops = gimple_vuse_ops (stmt);
- 
-   gcc_assert (VEC_length (tree, build_vuses) <= 1);
- 
-   gcc_assert ((!old_ops && !gimple_vuse (stmt))
- 	      || (old_ops && gimple_vuse (stmt)));
- 
-   /* Set the symbols referenced by STMT.  */
-   gimple_set_loaded_syms (stmt, build_loads, &operands_bitmap_obstack);
- 
-   /* Add a may-use if we have a VDEF but no VUSE.  */
-   if (VEC_length (tree, build_vuses) == 0
-       && VEC_length (tree, build_vdefs) == 1)
-     VEC_safe_push (tree, heap, build_vuses,
- 		   VEC_index (tree, build_vdefs, 0));
- 
-   /* If nothing changed, fine.  */
-   if (VEC_length (tree, build_vuses) == (old_ops ? 1 : 0))
-     {
-       if (old_ops)
- 	set_virtual_use_link (USE_OP_PTR (old_ops), stmt);
-       return;
-     }
- 
-   /* Add a VUSE and mark the gimple VOP for renaming.  */
-   if (VEC_length (tree, build_vuses) == 1)
-     {
-       struct use_optype_d new_list;
-       gimple_set_vuse (stmt, VEC_index (tree, build_vuses, 0));
-       new_list.next = NULL;
-       add_use_op (stmt, gimple_vuse_ptr (stmt), &new_list);
-       gimple_set_vuse_ops (stmt, new_list.next);
-       mark_sym_for_renaming (gimple_vop (cfun));
-     }
- 
-   /* Remove the VUSE.  */
-   else
-     {
-       delink_imm_use (USE_OP_PTR (old_ops));
-       old_ops->next = gimple_ssa_operands (cfun)->free_uses;
-       gimple_ssa_operands (cfun)->free_uses = old_ops;
-       gimple_set_vuse_ops (stmt, NULL);
-       gimple_set_vuse (stmt, NULL_TREE);
-     }
- }
- 
- /* Return a new VUSE operand vector for STMT.  */
-                                                                               
- static void
- finalize_ssa_vuses (gimple stmt)
- {
-   unsigned num, num_vdefs;
-   unsigned vuse_index;
- 
-   /* Remove superfluous VUSE operands.  If the statement already has a
-      VDEF operator for a variable 'a', then a VUSE for 'a' is not
-      needed because VDEFs imply a VUSE of the variable.  For instance,
-      suppose that variable 'a' is pointed-to by p and q:
- 
- 	      # VUSE <a_2>
- 	      # a_3 = VDEF <a_2>
- 	      *p = *q;
- 
-      The VUSE <a_2> is superfluous because it is implied by the
-      VDEF operator.  */
-   num = VEC_length (tree, build_vuses);
-   num_vdefs = VEC_length (tree, build_vdefs);
- 
-   if (num > 0 && num_vdefs > 0)
-     for (vuse_index = 0; vuse_index < VEC_length (tree, build_vuses); )
-       {
- 	tree vuse;
- 	vuse = VEC_index (tree, build_vuses, vuse_index);
- 	if (TREE_CODE (vuse) != SSA_NAME)
- 	  {
- 	    var_ann_t ann = var_ann (vuse);
- 	    ann->in_vuse_list = 0;
- 	    if (ann->in_vdef_list)
- 	      {
- 		VEC_ordered_remove (tree, build_vuses, vuse_index);
- 		continue;
- 	      }
- 	  }
- 	vuse_index++;
-       }
- 
-   finalize_ssa_vuse_ops (stmt);
  }
  
  
--- 659,664 ----
*************** finalize_ssa_stmt_operands (gimple stmt)
*** 803,813 ****
  {
    finalize_ssa_defs (stmt);
    finalize_ssa_uses (stmt);
-   if (gimple_has_mem_ops (stmt))
-     {
-       finalize_ssa_vdefs (stmt);
-       finalize_ssa_vuses (stmt);
-     }
    cleanup_build_arrays ();
  }
  
--- 695,700 ----
*************** free_stmt_operands (gimple stmt)
*** 1396,1403 ****
  {
    def_optype_p defs = gimple_def_ops (stmt), last_def;
    use_optype_p uses = gimple_use_ops (stmt), last_use;
-   use_optype_p vuses = gimple_vuse_ops (stmt);
-   def_optype_p vdefs = gimple_vdef_ops (stmt);
  
    if (defs)
      {
--- 1283,1288 ----
*************** free_stmt_operands (gimple stmt)
*** 1418,1440 ****
        gimple_set_use_ops (stmt, NULL);
      }
  
-   if (vuses)
-     {
-       delink_imm_use (USE_OP_PTR (vuses));
-       vuses->next = gimple_ssa_operands (cfun)->free_uses;
-       gimple_ssa_operands (cfun)->free_uses = vuses;
-       gimple_set_vuse_ops (stmt, NULL);
-       gimple_set_vuse (stmt, NULL_TREE);
-     }
- 
-   if (vdefs)
-     {
-       vdefs->next = gimple_ssa_operands (cfun)->free_defs;
-       gimple_ssa_operands (cfun)->free_defs = vdefs;
-       gimple_set_vdef_ops (stmt, NULL);
-       gimple_set_vdef (stmt, NULL_TREE);
-     }
- 
    if (gimple_has_ops (stmt))
      gimple_set_addresses_taken (stmt, NULL);
  
--- 1303,1308 ----
*************** free_stmt_operands (gimple stmt)
*** 1442,1447 ****
--- 1310,1317 ----
      {
        gimple_set_stored_syms (stmt, NULL, &operands_bitmap_obstack);
        gimple_set_loaded_syms (stmt, NULL, &operands_bitmap_obstack);
+       gimple_set_vuse (stmt, NULL_TREE);
+       gimple_set_vdef (stmt, NULL_TREE);
      }
  }
  
*************** copy_virtual_operands (gimple dest, gimp
*** 1475,1484 ****
    if (!gimple_has_mem_ops (src))
      return;
  
!   gimple_set_vdef_ops (dest, NULL);
!   gimple_set_vuse_ops (dest, NULL);
!   gimple_set_vdef (dest, NULL_TREE);
!   gimple_set_vuse (dest, NULL_TREE);
  
    gimple_set_stored_syms (dest, gimple_stored_syms (src),
  			  &operands_bitmap_obstack);
--- 1345,1354 ----
    if (!gimple_has_mem_ops (src))
      return;
  
!   gcc_assert (gimple_vdef (dest) != NULL_TREE
! 	      || gimple_vdef (src) == NULL_TREE);
!   gcc_assert (gimple_vuse (dest) != NULL_TREE
! 	      || gimple_vuse (src) == NULL_TREE);
  
    gimple_set_stored_syms (dest, gimple_stored_syms (src),
  			  &operands_bitmap_obstack);
*************** copy_virtual_operands (gimple dest, gimp
*** 1486,1507 ****
  			  &operands_bitmap_obstack);
  
    if (gimple_vuse (src))
!     {
!       struct use_optype_d new_list;
!       new_list.next = NULL;
!       gimple_set_vuse (dest, gimple_vuse (src));
!       add_use_op (dest, gimple_vuse_ptr (dest), &new_list);
!       gimple_set_vuse_ops (dest, new_list.next);
!     }
  
    if (gimple_vdef (src))
!     {
!       struct def_optype_d new_list;
!       new_list.next = NULL;
!       gimple_set_vdef (dest, gimple_vdef (src));
!       add_def_op (gimple_vdef_ptr (dest), &new_list);
!       gimple_set_vdef_ops (dest, new_list.next);
!     }
  }
  
  
--- 1356,1365 ----
  			  &operands_bitmap_obstack);
  
    if (gimple_vuse (src))
!     SET_USE (gimple_vuse_op (dest), gimple_vuse (src));
  
    if (gimple_vdef (src))
!     SET_DEF (gimple_vdef_op (dest), gimple_vdef (src));
  }
  
  
*************** push_stmt_changes (gimple *stmt_p)
*** 1724,1732 ****
    if (gimple_references_memory_p (stmt))
      {
        tree op;
-       ssa_op_iter i;
  
!       FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_VUSE)
  	{
  	  tree sym = TREE_CODE (op) == SSA_NAME ? SSA_NAME_VAR (op) : op;
  	  if (buf->loads == NULL)
--- 1582,1589 ----
    if (gimple_references_memory_p (stmt))
      {
        tree op;
  
!       if ((op = gimple_vuse (stmt)) != NULL_TREE)
  	{
  	  tree sym = TREE_CODE (op) == SSA_NAME ? SSA_NAME_VAR (op) : op;
  	  if (buf->loads == NULL)
*************** push_stmt_changes (gimple *stmt_p)
*** 1734,1740 ****
  	  bitmap_set_bit (buf->loads, DECL_UID (sym));
  	}
  
!       FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_VDEF)
  	{
  	  tree sym = TREE_CODE (op) == SSA_NAME ? SSA_NAME_VAR (op) : op;
  	  if (buf->stores == NULL)
--- 1591,1597 ----
  	  bitmap_set_bit (buf->loads, DECL_UID (sym));
  	}
  
!       if ((op = gimple_vdef (stmt)) != NULL_TREE)
  	{
  	  tree sym = TREE_CODE (op) == SSA_NAME ? SSA_NAME_VAR (op) : op;
  	  if (buf->stores == NULL)
*************** pop_stmt_changes (gimple *stmt_p)
*** 1807,1815 ****
    if (gimple_references_memory_p (stmt))
      {
        tree op;
-       ssa_op_iter i;
  
!       FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_VUSE)
  	{
  	  tree sym = TREE_CODE (op) == SSA_NAME ? SSA_NAME_VAR (op) : op;
  	  if (loads == NULL)
--- 1664,1671 ----
    if (gimple_references_memory_p (stmt))
      {
        tree op;
  
!       if ((op = gimple_vuse (stmt)) != NULL_TREE)
  	{
  	  tree sym = TREE_CODE (op) == SSA_NAME ? SSA_NAME_VAR (op) : op;
  	  if (loads == NULL)
*************** pop_stmt_changes (gimple *stmt_p)
*** 1817,1823 ****
  	  bitmap_set_bit (loads, DECL_UID (sym));
  	}
  
!       FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_VDEF)
  	{
  	  tree sym = TREE_CODE (op) == SSA_NAME ? SSA_NAME_VAR (op) : op;
  	  if (stores == NULL)
--- 1673,1679 ----
  	  bitmap_set_bit (loads, DECL_UID (sym));
  	}
  
!       if ((op = gimple_vdef (stmt)) != NULL_TREE)
  	{
  	  tree sym = TREE_CODE (op) == SSA_NAME ? SSA_NAME_VAR (op) : op;
  	  if (stores == NULL)
Index: alias-improvements/gcc/tree-ssa-operands.h
===================================================================
*** alias-improvements.orig/gcc/tree-ssa-operands.h	2009-01-17 21:54:37.000000000 +0100
--- alias-improvements/gcc/tree-ssa-operands.h	2009-01-17 22:35:01.000000000 +0100
*************** enum ssa_op_iter_type {
*** 128,135 ****
    ssa_op_iter_none = 0,
    ssa_op_iter_tree,
    ssa_op_iter_use,
!   ssa_op_iter_def,
!   ssa_op_iter_vdef
  };
  
  /* This structure is used in the operand iterator loops.  It contains the 
--- 128,134 ----
    ssa_op_iter_none = 0,
    ssa_op_iter_tree,
    ssa_op_iter_use,
!   ssa_op_iter_def
  };
  
  /* This structure is used in the operand iterator loops.  It contains the 
*************** enum ssa_op_iter_type {
*** 139,153 ****
  
  typedef struct ssa_operand_iterator_d
  {
    def_optype_p defs;
    use_optype_p uses;
-   use_optype_p vuses;
-   def_optype_p vdefs;
-   enum ssa_op_iter_type iter_type;
    int phi_i;
    int num_phi;
    gimple phi_stmt;
-   bool done;
  } ssa_op_iter;
  
  /* These flags are used to determine which operands are returned during 
--- 138,150 ----
  
  typedef struct ssa_operand_iterator_d
  {
+   bool done;
+   enum ssa_op_iter_type iter_type;
    def_optype_p defs;
    use_optype_p uses;
    int phi_i;
    int num_phi;
    gimple phi_stmt;
  } ssa_op_iter;
  
  /* These flags are used to determine which operands are returned during 
*************** typedef struct ssa_operand_iterator_d
*** 155,166 ****
  #define SSA_OP_USE		0x01	/* Real USE operands.  */
  #define SSA_OP_DEF		0x02	/* Real DEF operands.  */
  #define SSA_OP_VUSE		0x04	/* VUSE operands.  */
! /* ???  Kill either SSA_OP_VUSE or SSA_OP_VMAYUSE.  */
! #define SSA_OP_VMAYUSE		0x04	/* USE portion of VDEFS.  */
! #define SSA_OP_VDEF		0x10	/* DEF portion of VDEFS.  */
  
  /* These are commonly grouped operand flags.  */
! #define SSA_OP_VIRTUAL_USES	(SSA_OP_VUSE | SSA_OP_VMAYUSE)
  #define SSA_OP_VIRTUAL_DEFS	(SSA_OP_VDEF)
  #define SSA_OP_ALL_VIRTUALS     (SSA_OP_VIRTUAL_USES | SSA_OP_VIRTUAL_DEFS)
  #define SSA_OP_ALL_USES		(SSA_OP_VIRTUAL_USES | SSA_OP_USE)
--- 152,161 ----
  #define SSA_OP_USE		0x01	/* Real USE operands.  */
  #define SSA_OP_DEF		0x02	/* Real DEF operands.  */
  #define SSA_OP_VUSE		0x04	/* VUSE operands.  */
! #define SSA_OP_VDEF		0x08	/* VDEF operands.  */
  
  /* These are commonly grouped operand flags.  */
! #define SSA_OP_VIRTUAL_USES	(SSA_OP_VUSE)
  #define SSA_OP_VIRTUAL_DEFS	(SSA_OP_VDEF)
  #define SSA_OP_ALL_VIRTUALS     (SSA_OP_VIRTUAL_USES | SSA_OP_VIRTUAL_DEFS)
  #define SSA_OP_ALL_USES		(SSA_OP_VIRTUAL_USES | SSA_OP_USE)
Index: alias-improvements/gcc/tree-ssa-phiprop.c
===================================================================
*** alias-improvements.orig/gcc/tree-ssa-phiprop.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/tree-ssa-phiprop.c	2009-01-17 21:54:38.000000000 +0100
*************** static bool
*** 105,116 ****
  phivn_valid_p (struct phiprop_d *phivn, tree name, basic_block bb)
  {
    gimple vop_stmt = phivn[SSA_NAME_VERSION (name)].vop_stmt;
-   ssa_op_iter ui;
    tree vuse;
  
    /* The def stmts of all virtual uses need to be post-dominated
       by bb.  */
!   FOR_EACH_SSA_TREE_OPERAND (vuse, vop_stmt, ui, SSA_OP_VUSE)
      {
        gimple use_stmt;
        imm_use_iterator ui2;
--- 105,115 ----
  phivn_valid_p (struct phiprop_d *phivn, tree name, basic_block bb)
  {
    gimple vop_stmt = phivn[SSA_NAME_VERSION (name)].vop_stmt;
    tree vuse;
  
    /* The def stmts of all virtual uses need to be post-dominated
       by bb.  */
!   if ((vuse = gimple_vuse (vop_stmt)))
      {
        gimple use_stmt;
        imm_use_iterator ui2;
*************** phivn_valid_p (struct phiprop_d *phivn, 
*** 120,126 ****
  	{
  	  /* If BB does not dominate a VDEF, the value is invalid.  */
  	  if (((is_gimple_assign (use_stmt)
! 	        && !ZERO_SSA_OPERANDS (use_stmt, SSA_OP_VDEF))
  	       || gimple_code (use_stmt) == GIMPLE_PHI)
  	      && !dominated_by_p (CDI_DOMINATORS, gimple_bb (use_stmt), bb))
  	    {
--- 119,125 ----
  	{
  	  /* If BB does not dominate a VDEF, the value is invalid.  */
  	  if (((is_gimple_assign (use_stmt)
! 	        && gimple_vdef (use_stmt))
  	       || gimple_code (use_stmt) == GIMPLE_PHI)
  	      && !dominated_by_p (CDI_DOMINATORS, gimple_bb (use_stmt), bb))
  	    {
*************** propagate_with_phi (basic_block bb, gimp
*** 270,276 ****
    phi_inserted = false;
    FOR_EACH_IMM_USE_STMT (use_stmt, ui, ptr)
      {
-       ssa_op_iter ui2;
        tree vuse;
  
        /* Check whether this is a load of *ptr.  */
--- 269,274 ----
*************** propagate_with_phi (basic_block bb, gimp
*** 284,290 ****
  
        /* Check if we can move the loads.  The def stmts of all virtual uses
  	 need to be post-dominated by bb.  */
!       FOR_EACH_SSA_TREE_OPERAND (vuse, use_stmt, ui2, SSA_OP_VUSE)
  	{
  	  gimple def_stmt = SSA_NAME_DEF_STMT (vuse);
  	  if (!SSA_NAME_IS_DEFAULT_DEF (vuse)
--- 282,288 ----
  
        /* Check if we can move the loads.  The def stmts of all virtual uses
  	 need to be post-dominated by bb.  */
!       if ((vuse = gimple_vuse (use_stmt)) != NULL_TREE)
  	{
  	  gimple def_stmt = SSA_NAME_DEF_STMT (vuse);
  	  if (!SSA_NAME_IS_DEFAULT_DEF (vuse)
Index: alias-improvements/gcc/tree-ssa-propagate.c
===================================================================
*** alias-improvements.orig/gcc/tree-ssa-propagate.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/tree-ssa-propagate.c	2009-01-17 21:54:38.000000000 +0100
*************** update_call_from_tree (gimple_stmt_itera
*** 730,736 ****
  
        new_stmt = gimple_build_call_vec (fn, args);
        gimple_call_set_lhs (new_stmt, lhs);
-       copy_virtual_operands (new_stmt, stmt);
        move_ssa_defining_stmt_for_defs (new_stmt, stmt);
        gimple_set_location (new_stmt, gimple_location (stmt));
        gsi_replace (si_p, new_stmt, false);
--- 730,735 ----
*************** update_call_from_tree (gimple_stmt_itera
*** 750,756 ****
               Introduce a new GIMPLE_ASSIGN statement.  */
            STRIP_USELESS_TYPE_CONVERSION (expr);
            new_stmt = gimple_build_assign (lhs, expr);
-           copy_virtual_operands (new_stmt, stmt);
            move_ssa_defining_stmt_for_defs (new_stmt, stmt);
          }
        else if (!TREE_SIDE_EFFECTS (expr))
--- 749,754 ----
*************** stmt_makes_single_load (gimple stmt)
*** 842,848 ****
        != GIMPLE_SINGLE_RHS)
      return false;
  
!   if (ZERO_SSA_OPERANDS (stmt, SSA_OP_VDEF|SSA_OP_VUSE))
      return false;
  
    rhs = gimple_assign_rhs1 (stmt);
--- 840,846 ----
        != GIMPLE_SINGLE_RHS)
      return false;
  
!   if (!gimple_vuse (stmt))
      return false;
  
    rhs = gimple_assign_rhs1 (stmt);
*************** stmt_makes_single_store (gimple stmt)
*** 867,873 ****
        && gimple_code (stmt) != GIMPLE_CALL)
      return false;
  
!   if (ZERO_SSA_OPERANDS (stmt, SSA_OP_VDEF))
      return false;
  
    lhs = gimple_get_lhs (stmt);
--- 865,871 ----
        && gimple_code (stmt) != GIMPLE_CALL)
      return false;
  
!   if (!gimple_vdef (stmt))
      return false;
  
    lhs = gimple_get_lhs (stmt);
Index: alias-improvements/gcc/tree-ssa-reassoc.c
===================================================================
*** alias-improvements.orig/gcc/tree-ssa-reassoc.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/tree-ssa-reassoc.c	2009-01-17 21:54:38.000000000 +0100
*************** get_rank (tree e)
*** 242,248 ****
  	return 0;
  
        if (!is_gimple_assign (stmt)
! 	  || !ZERO_SSA_OPERANDS (stmt, SSA_OP_VIRTUAL_DEFS))
  	return bb_rank[gimple_bb (stmt)->index];
  
        /* If we already have a rank for this expression, use that.  */
--- 242,248 ----
  	return 0;
  
        if (!is_gimple_assign (stmt)
! 	  || gimple_vdef (stmt))
  	return bb_rank[gimple_bb (stmt)->index];
  
        /* If we already have a rank for this expression, use that.  */
Index: alias-improvements/gcc/tree-ssa-sink.c
===================================================================
*** alias-improvements.orig/gcc/tree-ssa-sink.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/tree-ssa-sink.c	2009-01-17 21:54:38.000000000 +0100
*************** is_hidden_global_store (gimple stmt)
*** 139,145 ****
    /* Check virtual definitions.  If we get here, the only virtual
       definitions we should see are those generated by assignment or call
       statements.  */
!   if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_VIRTUAL_DEFS))
      {
        tree lhs;
  
--- 139,145 ----
    /* Check virtual definitions.  If we get here, the only virtual
       definitions we should see are those generated by assignment or call
       statements.  */
!   if (gimple_vdef (stmt))
      {
        tree lhs;
  
*************** statement_sink_location (gimple stmt, ba
*** 311,317 ****
        || code == FILTER_EXPR
        || is_hidden_global_store (stmt)
        || gimple_has_volatile_ops (stmt)
!       || !ZERO_SSA_OPERANDS (stmt, SSA_OP_VUSE))
      return false;
    
    FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, iter, SSA_OP_ALL_DEFS)
--- 311,317 ----
        || code == FILTER_EXPR
        || is_hidden_global_store (stmt)
        || gimple_has_volatile_ops (stmt)
!       || gimple_vuse (stmt))
      return false;
    
    FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, iter, SSA_OP_ALL_DEFS)
Index: alias-improvements/gcc/tree-ssa-ter.c
===================================================================
*** alias-improvements.orig/gcc/tree-ssa-ter.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/tree-ssa-ter.c	2009-01-17 21:54:38.000000000 +0100
*************** is_replaceable_p (gimple stmt)
*** 412,418 ****
      return false;
  
    /* There must be no VDEFs.  */
!   if (!(ZERO_SSA_OPERANDS (stmt, SSA_OP_VDEF)))
      return false;
  
    /* Without alias info we can't move around loads.  */
--- 412,418 ----
      return false;
  
    /* There must be no VDEFs.  */
!   if (gimple_vdef (stmt))
      return false;
  
    /* Without alias info we can't move around loads.  */
*************** process_replaceable (temp_expr_table_p t
*** 504,510 ****
    tab->expr_decl_uids[version] = def_vars;
  
    /* If there are VUSES, add a dependence on virtual defs.  */
!   if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_VUSE))
      {
        make_dependent_on_partition (tab, version, VIRTUAL_PARTITION (tab));
        add_to_partition_kill_list (tab, VIRTUAL_PARTITION (tab), version);
--- 504,510 ----
    tab->expr_decl_uids[version] = def_vars;
  
    /* If there are VUSES, add a dependence on virtual defs.  */
!   if (gimple_vuse (stmt))
      {
        make_dependent_on_partition (tab, version, VIRTUAL_PARTITION (tab));
        add_to_partition_kill_list (tab, VIRTUAL_PARTITION (tab), version);
*************** find_replaceable_in_bb (temp_expr_table_
*** 639,645 ****
  
        /* A V_{MAY,MUST}_DEF kills any expression using a virtual operand,
  	 including the current stmt.  */
!       if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_VIRTUAL_DEFS))
          kill_virtual_exprs (tab);
      }
  }
--- 639,645 ----
  
        /* A V_{MAY,MUST}_DEF kills any expression using a virtual operand,
  	 including the current stmt.  */
!       if (gimple_vdef (stmt))
          kill_virtual_exprs (tab);
      }
  }
Index: alias-improvements/gcc/tree-ssa.c
===================================================================
*** alias-improvements.orig/gcc/tree-ssa.c	2009-01-17 21:54:37.000000000 +0100
--- alias-improvements/gcc/tree-ssa.c	2009-01-17 21:54:38.000000000 +0100
*************** verify_ssa (bool check_modified_stmt)
*** 608,614 ****
  
  	      if (base_address
  		  && SSA_VAR_P (base_address)
! 		  && ZERO_SSA_OPERANDS (stmt, SSA_OP_VDEF))
  		{
  		  error ("statement makes a memory store, but has no VDEFS");
  		  print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
--- 608,614 ----
  
  	      if (base_address
  		  && SSA_VAR_P (base_address)
! 		  && !gimple_vdef (stmt))
  		{
  		  error ("statement makes a memory store, but has no VDEFS");
  		  print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
*************** verify_ssa (bool check_modified_stmt)
*** 616,634 ****
  		}
  	    }
  
! 	  FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_ALL_VIRTUALS)
  	    {
! 	      if (verify_ssa_name (op, true))
! 		{
! 		  error ("in statement");
! 		  print_gimple_stmt (stderr, stmt, 0, TDF_VOPS|TDF_MEMSYMS);
! 		  goto err;
! 		}
! 	    }
! 
! 	  FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE|SSA_OP_DEF)
! 	    {
! 	      if (verify_ssa_name (op, false))
  		{
  		  error ("in statement");
  		  print_gimple_stmt (stderr, stmt, 0, TDF_VOPS|TDF_MEMSYMS);
--- 616,625 ----
  		}
  	    }
  
! 	  FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter,
! 				     SSA_OP_ALL_USES|SSA_OP_ALL_DEFS)
  	    {
! 	      if (verify_ssa_name (op, !is_gimple_reg (op)))
  		{
  		  error ("in statement");
  		  print_gimple_stmt (stderr, stmt, 0, TDF_VOPS|TDF_MEMSYMS);
*************** delete_tree_ssa (void)
*** 782,789 ****
  
  	  if (gimple_has_mem_ops (stmt))
  	    {
- 	      gimple_set_vdef_ops (stmt, NULL);
- 	      gimple_set_vuse_ops (stmt, NULL);
  	      gimple_set_vdef (stmt, NULL_TREE);
  	      gimple_set_vuse (stmt, NULL_TREE);
  	      BITMAP_FREE (stmt->gsmem.membase.stores);
--- 773,778 ----
*************** warn_uninitialized_var (tree *tp, int *w
*** 1256,1262 ****
  	if (data->stmt == NULL)
  	  return NULL_TREE;
  
! 	vuse = SINGLE_SSA_USE_OPERAND (data->stmt, SSA_OP_VUSE);
  	if (vuse == NULL_USE_OPERAND_P)
  	    return NULL_TREE;
  
--- 1245,1251 ----
  	if (data->stmt == NULL)
  	  return NULL_TREE;
  
! 	vuse = gimple_vuse_op (data->stmt);
  	if (vuse == NULL_USE_OPERAND_P)
  	    return NULL_TREE;
  
Index: alias-improvements/gcc/tree-vect-analyze.c
===================================================================
*** alias-improvements.orig/gcc/tree-vect-analyze.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/tree-vect-analyze.c	2009-01-17 21:54:38.000000000 +0100
*************** vect_stmt_relevant_p (gimple stmt, loop_
*** 3792,3798 ****
  
    /* changing memory.  */
    if (gimple_code (stmt) != GIMPLE_PHI)
!     if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_VIRTUAL_DEFS))
        {
  	if (vect_print_dump_info (REPORT_DETAILS))
  	  fprintf (vect_dump, "vec_stmt_relevant_p: stmt has vdefs.");
--- 3792,3798 ----
  
    /* changing memory.  */
    if (gimple_code (stmt) != GIMPLE_PHI)
!     if (gimple_vdef (stmt))
        {
  	if (vect_print_dump_info (REPORT_DETAILS))
  	  fprintf (vect_dump, "vec_stmt_relevant_p: stmt has vdefs.");
Index: alias-improvements/gcc/tree-vect-transform.c
===================================================================
*** alias-improvements.orig/gcc/tree-vect-transform.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/tree-vect-transform.c	2009-01-17 21:54:38.000000000 +0100
*************** vectorizable_call (gimple stmt, gimple_s
*** 3316,3322 ****
        return false;
      }
  
!   gcc_assert (ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS));
  
    if (modifier == NARROW)
      ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits_out;
--- 3316,3322 ----
        return false;
      }
  
!   gcc_assert (!gimple_vuse (stmt));
  
    if (modifier == NARROW)
      ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits_out;
*************** vect_gen_widened_results_half (enum tree
*** 3478,3485 ****
  { 
    gimple new_stmt;
    tree new_temp; 
-   tree sym; 
-   ssa_op_iter iter;
   
    /* Generate half of the widened result:  */ 
    if (code == CALL_EXPR) 
--- 3478,3483 ----
*************** vect_gen_widened_results_half (enum tree
*** 3505,3520 ****
      } 
    vect_finish_stmt_generation (stmt, new_stmt, gsi);
  
-   if (code == CALL_EXPR)
-     {
-       FOR_EACH_SSA_TREE_OPERAND (sym, new_stmt, iter, SSA_OP_ALL_VIRTUALS)
-         {
-           if (TREE_CODE (sym) == SSA_NAME)
-             sym = SSA_NAME_VAR (sym);
-           mark_sym_for_renaming (sym);
-         }
-     }
- 
    return new_stmt;
  }
  
--- 3503,3508 ----
*************** vectorizable_conversion (gimple stmt, gi
*** 3679,3687 ****
      case NONE:
        for (j = 0; j < ncopies; j++)
  	{
- 	  tree sym;
- 	  ssa_op_iter iter;
- 
  	  if (j == 0)
  	    vect_get_vec_defs (op0, NULL, stmt, &vec_oprnds0, NULL, slp_node); 
  	  else
--- 3667,3672 ----
*************** vectorizable_conversion (gimple stmt, gi
*** 3696,3708 ****
  	      new_temp = make_ssa_name (vec_dest, new_stmt);
  	      gimple_call_set_lhs (new_stmt, new_temp);
  	      vect_finish_stmt_generation (stmt, new_stmt, gsi);
- 	      FOR_EACH_SSA_TREE_OPERAND (sym, new_stmt, iter, 
- 					 SSA_OP_ALL_VIRTUALS)
- 		{
- 		  if (TREE_CODE (sym) == SSA_NAME)
- 		    sym = SSA_NAME_VAR (sym);
- 		  mark_sym_for_renaming (sym);
- 		}
  	      if (slp_node)
  		VEC_quick_push (gimple, SLP_TREE_VEC_STMTS (slp_node), new_stmt);
  	    }
--- 3681,3686 ----
*************** vect_create_mask_and_perm (gimple stmt, 
*** 6005,6012 ****
    stmt_vec_info next_stmt_info;
    int i, group_size, stride, dr_chain_size;
    tree first_vec, second_vec, data_ref;
-   tree sym;
-   ssa_op_iter iter;
    VEC (tree, heap) *params = NULL;
  
    /* Create a vector mask.  */
--- 5983,5988 ----
*************** vect_create_mask_and_perm (gimple stmt, 
*** 6044,6055 ****
        data_ref = make_ssa_name (perm_dest, perm_stmt);
        gimple_call_set_lhs (perm_stmt, data_ref);
        vect_finish_stmt_generation (stmt, perm_stmt, gsi);
-       FOR_EACH_SSA_TREE_OPERAND (sym, perm_stmt, iter, SSA_OP_ALL_VIRTUALS)
-         {
-           if (TREE_CODE (sym) == SSA_NAME)
-             sym = SSA_NAME_VAR (sym);
-           mark_sym_for_renaming (sym);
-         }
  
        /* Store the vector statement in NODE.  */ 
        VEC_replace (gimple, SLP_TREE_VEC_STMTS (node), 
--- 6020,6025 ----
Index: alias-improvements/gcc/tree-vrp.c
===================================================================
*** alias-improvements.orig/gcc/tree-vrp.c	2009-01-17 21:53:58.000000000 +0100
--- alias-improvements/gcc/tree-vrp.c	2009-01-17 21:54:38.000000000 +0100
*************** stmt_interesting_for_vrp (gimple stmt)
*** 5278,5284 ****
  	  && ((is_gimple_call (stmt)
  	       && gimple_call_fndecl (stmt) != NULL_TREE
  	       && DECL_IS_BUILTIN (gimple_call_fndecl (stmt)))
! 	      || ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS)))
  	return true;
      }
    else if (gimple_code (stmt) == GIMPLE_COND
--- 5278,5284 ----
  	  && ((is_gimple_call (stmt)
  	       && gimple_call_fndecl (stmt) != NULL_TREE
  	       && DECL_IS_BUILTIN (gimple_call_fndecl (stmt)))
! 	      || !gimple_vuse (stmt)))
  	return true;
      }
    else if (gimple_code (stmt) == GIMPLE_COND
*************** vrp_visit_stmt (gimple stmt, edge *taken
*** 6097,6103 ****
        if ((is_gimple_call (stmt)
  	   && gimple_call_fndecl (stmt) != NULL_TREE
  	   && DECL_IS_BUILTIN (gimple_call_fndecl (stmt)))
! 	  || ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
  	return vrp_visit_assignment_or_call (stmt, output_p);
      }
    else if (gimple_code (stmt) == GIMPLE_COND)
--- 6097,6103 ----
        if ((is_gimple_call (stmt)
  	   && gimple_call_fndecl (stmt) != NULL_TREE
  	   && DECL_IS_BUILTIN (gimple_call_fndecl (stmt)))
! 	  || !gimple_vuse (stmt))
  	return vrp_visit_assignment_or_call (stmt, output_p);
      }
    else if (gimple_code (stmt) == GIMPLE_COND)



More information about the Gcc-patches mailing list