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

	PR tree-optimization/18587

	* tree-ssa-operands.c (struct opbuild_list_d, OPBUILD_LAST): Delete.
	(build_defs, build_uses, build_v_may_defs, build_v_must_defs,
	build_vuses): Change to VEC type.
	(opbuild_initialize_virtual, opbuild_initialize_real, opbuild_free,
	opbuild_num_elems, opbuild_append_real, opbuild_append_virtual,
	opbuild_first, opbuild_next, opbuild_elem_real, opbuild_elem_virtual,
	opbuild_elem_uid, opbuild_clear, opbuild_remove_elem): Delete.
	(get_name_decl): New.  Return DECL_UID of base variable.
	(operand_build_cmp): New.  qsort comparison routine.
	(operand_build_sort_virtual): New.  Sort virtual build vector.
	(init_ssa_operands, fini_ssa_operands): Use VEC routines.
	(FINALIZE_OPBUILD_BASE, FINALIZE_OPBUILD_ELEM): Use VEC_Index.
	(FINALIZE_BASE): Use get_name_decl.
	(finalize_ssa_defs, finalize_ssa_uses, cleanup_v_may_defs,
	finalize_ssa_v_may_defs, finalize_ssa_vuses, finalize_ssa_v_must_defs,
	(start_ssa_stmt_operands, append_def, append_use, append_vuse,
	append_v_may_def, append_v_must_def): Replace opbuild_* routines with
	direct VEC_* manipulations.
	(build_ssa_operands): Call operand_build_sort_virtual.
	(copy_virtual_operand, create_ssa_artficial_load_stmt,
	add_call_clobber_ops, add_call_read_ops): Replace opbuild_* routines
	with direct VEC_* manipulations.
	* tree-ssa-opfinalize.h (FINALIZE_FUNC): Replace opbuild_* routines
	with direct VEC manipulations.


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

3 files changed, 172 insertions, 324 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 4a87d1f8b54..a21d4d83097 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,31 @@
+2005-10-05  Andrew MacLeod  <amacleod@redhat.com>
+
+	PR tree-optimization/18587
+	* tree-ssa-operands.c (struct opbuild_list_d, OPBUILD_LAST): Delete.
+	(build_defs, build_uses, build_v_may_defs, build_v_must_defs,
+	build_vuses): Change to VEC type.
+	(opbuild_initialize_virtual, opbuild_initialize_real, opbuild_free,
+	opbuild_num_elems, opbuild_append_real, opbuild_append_virtual,
+	opbuild_first, opbuild_next, opbuild_elem_real, opbuild_elem_virtual,
+	opbuild_elem_uid, opbuild_clear, opbuild_remove_elem): Delete.
+	(get_name_decl): New.  Return DECL_UID of base variable. 
+	(operand_build_cmp): New.  qsort comparison routine.
+	(operand_build_sort_virtual): New.  Sort virtual build vector.
+	(init_ssa_operands, fini_ssa_operands): Use VEC routines.
+	(FINALIZE_OPBUILD_BASE, FINALIZE_OPBUILD_ELEM): Use VEC_Index.
+	(FINALIZE_BASE): Use get_name_decl.
+	(finalize_ssa_defs, finalize_ssa_uses, cleanup_v_may_defs,
+	finalize_ssa_v_may_defs, finalize_ssa_vuses, finalize_ssa_v_must_defs,
+	(start_ssa_stmt_operands, append_def, append_use, append_vuse, 
+	append_v_may_def, append_v_must_def): Replace opbuild_* routines with 
+	direct VEC_* manipulations.
+	(build_ssa_operands): Call operand_build_sort_virtual.
+	(copy_virtual_operand, create_ssa_artficial_load_stmt,
+	add_call_clobber_ops, add_call_read_ops): Replace opbuild_* routines 
+	with direct VEC_* manipulations.
+	* tree-ssa-opfinalize.h (FINALIZE_FUNC): Replace opbuild_* routines
+	with direct VEC manipulations.
+
 2005-10-05  Paolo Bonzini  <bonzini@gnu.org>
 
 	PR tree-optimization/21419
diff --git a/gcc/tree-ssa-operands.c b/gcc/tree-ssa-operands.c
index 1c592573e81..30845546d28 100644
--- a/gcc/tree-ssa-operands.c
+++ b/gcc/tree-ssa-operands.c
@@ -103,34 +103,21 @@ Boston, MA 02110-1301, USA.  */
    to distinguish "reset the world" events from explicit MODIFY_EXPRs.  */
 #define opf_non_specific  (1 << 3)
 
-/* This structure maintain a sorted list of operands which is created by
-   parse_ssa_operand.  */
-struct opbuild_list_d GTY (())
-{
-  varray_type vars;     /* The VAR_DECLS tree.  */
-  varray_type uid;      /* The sort value for virtual symbols.  */
-  varray_type next;     /* The next index in the sorted list.  */
-  int first;            /* First element in list.  */
-  unsigned num;		/* Number of elements.  */
-};
-                                                                                
-#define OPBUILD_LAST     -1
-                                                                                
 
 /* Array for building all the def operands.  */
-static GTY (()) struct opbuild_list_d build_defs;
+static VEC(tree,heap) *build_defs;
 
 /* Array for building all the use operands.  */
-static GTY (()) struct opbuild_list_d build_uses;
+static VEC(tree,heap) *build_uses;
 
 /* Array for building all the v_may_def operands.  */
-static GTY (()) struct opbuild_list_d build_v_may_defs;
+static VEC(tree,heap) *build_v_may_defs;
 
 /* Array for building all the vuse operands.  */
-static GTY (()) struct opbuild_list_d build_vuses;
+static VEC(tree,heap) *build_vuses;
 
 /* Array for building all the v_must_def operands.  */
-static GTY (()) struct opbuild_list_d build_v_must_defs;
+static VEC(tree,heap) *build_v_must_defs;
 
 /* True if the operands for call clobbered vars are cached and valid.  */
 bool ssa_call_clobbered_cache_valid;
@@ -168,222 +155,65 @@ static vuse_optype_p free_vuses = NULL;
 static maydef_optype_p free_maydefs = NULL;
 static mustdef_optype_p free_mustdefs = NULL;
 
-/* Initialize a virtual operand build LIST called NAME with NUM elements.  */
-
-static inline void
-opbuild_initialize_virtual (struct  opbuild_list_d *list, int num, 
-			   const char *name)
-{
-  list->first = OPBUILD_LAST;
-  list->num = 0;
-  VARRAY_TREE_INIT (list->vars, num, name);
-  VARRAY_UINT_INIT (list->uid, num, "List UID");
-  VARRAY_INT_INIT (list->next, num, "List NEXT");
-}
-
-
-/* Initialize a real operand build LIST called NAME with NUM elements.  */
-
-static inline void
-opbuild_initialize_real (struct opbuild_list_d *list, int num, const char *name)
-{
-  list->first = OPBUILD_LAST;
-  list->num = 0;
-  VARRAY_TREE_PTR_INIT (list->vars, num, name);
-  VARRAY_INT_INIT (list->next, num, "List NEXT");
-  /* The UID field is not needed since we sort based on the pointer value.  */
-  list->uid = NULL;
-}
-
 
-/* Free memory used in virtual operand build object LIST.  */
-
-static inline void
-opbuild_free (struct opbuild_list_d *list)
-{
-  list->vars = NULL;
-  list->uid = NULL;
-  list->next = NULL;
-}
-
-
-/* Number of elements in an opbuild list.  */
+/* Return the DECL_UID of the base varaiable of T.  */
 
 static inline unsigned
-opbuild_num_elems (struct opbuild_list_d *list)
+get_name_decl (tree t)
 {
-  return list->num;
+  if (TREE_CODE (t) != SSA_NAME)
+    return DECL_UID (t);
+  else
+    return DECL_UID (SSA_NAME_VAR (t));
 }
 
+/* Comparison function for qsort used in operand_build_sort_virtual.  */
 
-/* Add VAR to the real operand list LIST, keeping it sorted and avoiding
-   duplicates.  The actual sort value is the tree pointer value.  */
-
-static inline void
-opbuild_append_real (struct opbuild_list_d *list, tree *var)
+static int
+operand_build_cmp (const void *p, const void *q)
 {
-  int index;
+  tree e1 = *((const tree *)p);
+  tree e2 = *((const tree *)q);
+  unsigned int u1,u2;
+
+  u1 = get_name_decl (e1);
+  u2 = get_name_decl (e2);
 
+  /* We want to sort in ascending order.  They can never be equal.  */
 #ifdef ENABLE_CHECKING
-  /* Ensure the real operand doesn't exist already.  */
-  for (index = list->first; 
-       index != OPBUILD_LAST; 
-       index = VARRAY_INT (list->next, index))
-    gcc_assert (VARRAY_TREE_PTR (list->vars, index) != var);
+  gcc_assert (u1 != u2);
 #endif
-
-  /* First item in the list.  */
-  index = VARRAY_ACTIVE_SIZE (list->vars);
-  if (index == 0)
-    list->first = index;
-  else
-    VARRAY_INT (list->next, index - 1) = index;
-  VARRAY_PUSH_INT (list->next, OPBUILD_LAST);
-  VARRAY_PUSH_TREE_PTR (list->vars, var);
-  list->num++;
+  return (u1 > u2 ? 1 : -1);
 }
 
-
-/* Add VAR to the virtual operand list LIST, keeping it sorted and avoiding
-   duplicates.  The actual sort value is the DECL UID of the base variable.  */
+/* Sort the virtual operands in LIST from lowest DECL_UID to highest.  */
 
 static inline void
-opbuild_append_virtual (struct opbuild_list_d *list, tree var)
+operand_build_sort_virtual (VEC(tree,heap) *list)
 {
-  int index, curr, last;
-  unsigned int var_uid;
-
-  if (TREE_CODE (var) != SSA_NAME)
-    var_uid = DECL_UID (var);
-  else
-    var_uid = DECL_UID (SSA_NAME_VAR (var));
-
-  index = VARRAY_ACTIVE_SIZE (list->vars);
-
-  if (index == 0)
+  int num = VEC_length (tree, list);
+  if (num < 2)
+    return;
+  if (num == 2)
     {
-      VARRAY_PUSH_TREE (list->vars, var);
-      VARRAY_PUSH_UINT (list->uid, var_uid);
-      VARRAY_PUSH_INT (list->next, OPBUILD_LAST);
-      list->first = 0;
-      list->num = 1;
+      if (get_name_decl (VEC_index (tree, list, 0)) 
+	  > get_name_decl (VEC_index (tree, list, 1)))
+	{  
+	  /* Swap elements if in the wrong order.  */
+	  tree tmp = VEC_index (tree, list, 0);
+	  VEC_replace (tree, list, 0, VEC_index (tree, list, 1));
+	  VEC_replace (tree, list, 1, tmp);
+	}
       return;
     }
-
-  last = OPBUILD_LAST;
-  /* Find the correct spot in the sorted list.  */
-  for (curr = list->first; 
-       curr != OPBUILD_LAST; 
-       last = curr, curr = VARRAY_INT (list->next, curr))
-    {
-      if (VARRAY_UINT (list->uid, curr) > var_uid)
-        break;
-    }
-
-  if (last == OPBUILD_LAST)
-    {
-      /* First item in the list.  */
-      VARRAY_PUSH_INT (list->next, list->first);
-      list->first = index;
-    }
-  else
-    {
-      /* Don't enter duplicates at all.  */
-      if (VARRAY_UINT (list->uid, last) == var_uid)
-        return;
-      
-      VARRAY_PUSH_INT (list->next, VARRAY_INT (list->next, last));
-      VARRAY_INT (list->next, last) = index;
-    }
-  VARRAY_PUSH_TREE (list->vars, var);
-  VARRAY_PUSH_UINT (list->uid, var_uid);
-  list->num++;
-}
-
-
-/*  Return the first element index in LIST.  OPBUILD_LAST means there are no 
-    more elements.  */
-
-static inline int
-opbuild_first (struct opbuild_list_d *list)
-{
-  if (list->num > 0)
-    return list->first;
-  else
-    return OPBUILD_LAST;
-}
-
-
-/* Return the next element after PREV in LIST.  */
-
-static inline int
-opbuild_next (struct opbuild_list_d *list, int prev)
-{
-  return VARRAY_INT (list->next, prev);
-}
-
-
-/* Return the real element at index ELEM in LIST.  */
-
-static inline tree *
-opbuild_elem_real (struct opbuild_list_d *list, int elem)
-{
-  return VARRAY_TREE_PTR (list->vars, elem);
-}
-
-
-/* Return the virtual element at index ELEM in LIST.  */
-
-static inline tree
-opbuild_elem_virtual (struct opbuild_list_d *list, int elem)
-{
-  return VARRAY_TREE (list->vars, elem);
+  /* There are 3 or more elements, call qsort.  */
+  qsort (VEC_address (tree, list), 
+	 VEC_length (tree, list), 
+	 sizeof (tree),
+	 operand_build_cmp);
 }
 
 
-/* Return the virtual element uid at index ELEM in LIST.  */
-static inline unsigned int
-opbuild_elem_uid (struct opbuild_list_d *list, int elem)
-{
-  return VARRAY_UINT (list->uid, elem);
-}
-
-
-/* Reset an operand build list.  */
-
-static inline void
-opbuild_clear (struct opbuild_list_d *list)
-{
-  list->first = OPBUILD_LAST;
-  VARRAY_POP_ALL (list->vars);
-  VARRAY_POP_ALL (list->next);
-  if (list->uid)
-    VARRAY_POP_ALL (list->uid);
-  list->num = 0;
-}
-
-
-/* Remove ELEM from LIST where PREV is the previous element.  Return the next 
-   element.  */
-
-static inline int 
-opbuild_remove_elem (struct opbuild_list_d *list, int elem, int prev)
-{
-  int ret;
-  if (prev != OPBUILD_LAST)
-    {
-      gcc_assert (VARRAY_INT (list->next, prev) == elem);
-      ret = VARRAY_INT (list->next, prev) = VARRAY_INT (list->next, elem);
-    }
-  else
-    {
-      gcc_assert (list->first == elem);
-      ret = list->first = VARRAY_INT (list->next, elem);
-    }
-  list->num--;
-  return ret;
-}
-
 
 /*  Return true if the ssa operands cache is active.  */
 
@@ -399,11 +229,12 @@ ssa_operands_active (void)
 void
 init_ssa_operands (void)
 {
-  opbuild_initialize_real (&build_defs, 5, "build defs");
-  opbuild_initialize_real (&build_uses, 10, "build uses");
-  opbuild_initialize_virtual (&build_vuses, 25, "build_vuses");
-  opbuild_initialize_virtual (&build_v_may_defs, 25, "build_v_may_defs");
-  opbuild_initialize_virtual (&build_v_must_defs, 25, "build_v_must_defs");
+  build_defs = VEC_alloc (tree, heap, 5);
+  build_uses = VEC_alloc (tree, heap, 10);
+  build_vuses = VEC_alloc (tree, heap, 25);
+  build_v_may_defs = VEC_alloc (tree, heap, 25);
+  build_v_must_defs = VEC_alloc (tree, heap, 25);
+
   gcc_assert (operand_memory == NULL);
   operand_memory_index = SSA_OPERAND_MEMORY_SIZE;
   ops_active = true;
@@ -416,11 +247,11 @@ void
 fini_ssa_operands (void)
 {
   struct ssa_operand_memory_d *ptr;
-  opbuild_free (&build_defs);
-  opbuild_free (&build_uses);
-  opbuild_free (&build_v_must_defs);
-  opbuild_free (&build_v_may_defs);
-  opbuild_free (&build_vuses);
+  VEC_free (tree, heap, build_defs);
+  VEC_free (tree, heap, build_uses);
+  VEC_free (tree, heap, build_v_must_defs);
+  VEC_free (tree, heap, build_v_may_defs);
+  VEC_free (tree, heap, build_vuses);
   free_defs = NULL;
   free_uses = NULL;
   free_vuses = NULL;
@@ -530,8 +361,10 @@ set_virtual_use_link (use_operand_p ptr, tree stmt)
 
 
 #define FINALIZE_OPBUILD		build_defs
-#define FINALIZE_OPBUILD_BASE(I)	opbuild_elem_real (&build_defs, (I))
-#define FINALIZE_OPBUILD_ELEM(I)	opbuild_elem_real (&build_defs, (I))
+#define FINALIZE_OPBUILD_BASE(I)	(tree *)VEC_index (tree,	\
+							   build_defs, (I))
+#define FINALIZE_OPBUILD_ELEM(I)	(tree *)VEC_index (tree,	\
+							   build_defs, (I))
 #define FINALIZE_FUNC			finalize_ssa_def_ops
 #define FINALIZE_ALLOC			alloc_def
 #define FINALIZE_FREE			free_defs
@@ -550,7 +383,7 @@ set_virtual_use_link (use_operand_p ptr, tree stmt)
 static void
 finalize_ssa_defs (tree stmt)
 {
-  unsigned int num = opbuild_num_elems (&build_defs);
+  unsigned int num = VEC_length (tree, build_defs);
   /* There should only be a single real definition per assignment.  */
   gcc_assert ((stmt && TREE_CODE (stmt) != MODIFY_EXPR) || num <= 1);
 
@@ -558,12 +391,14 @@ finalize_ssa_defs (tree stmt)
      find the elements at the beginning that are the same as the vector.  */
 
   finalize_ssa_def_ops (stmt);
-  opbuild_clear (&build_defs);
+  VEC_truncate (tree, build_defs, 0);
 }
 
 #define FINALIZE_OPBUILD	build_uses
-#define FINALIZE_OPBUILD_BASE(I)	opbuild_elem_real (&build_uses, (I))
-#define FINALIZE_OPBUILD_ELEM(I)	opbuild_elem_real (&build_uses, (I))
+#define FINALIZE_OPBUILD_BASE(I)	(tree *)VEC_index (tree,	\
+							   build_uses, (I))
+#define FINALIZE_OPBUILD_ELEM(I)	(tree *)VEC_index (tree,	\
+							   build_uses, (I))
 #define FINALIZE_FUNC		finalize_ssa_use_ops
 #define FINALIZE_ALLOC		alloc_use
 #define FINALIZE_FREE		free_uses
@@ -589,25 +424,26 @@ finalize_ssa_uses (tree stmt)
 #ifdef ENABLE_CHECKING
   {
     unsigned x;
-    unsigned num = opbuild_num_elems (&build_uses);
+    unsigned num = VEC_length (tree, build_uses);
 
     /* If the pointer to the operand is the statement itself, something is
        wrong.  It means that we are pointing to a local variable (the 
        initial call to get_stmt_operands does not pass a pointer to a 
        statement).  */
     for (x = 0; x < num; x++)
-      gcc_assert (*(opbuild_elem_real (&build_uses, x)) != stmt);
+      gcc_assert (*((tree *)VEC_index (tree, build_uses, x)) != stmt);
   }
 #endif
   finalize_ssa_use_ops (stmt);
-  opbuild_clear (&build_uses);
+  VEC_truncate (tree, build_uses, 0);
 }
                                                                               
                                                                               
 /* Return a new v_may_def operand vector for STMT, comparing to OLD_OPS_P.  */                                                                                
 #define FINALIZE_OPBUILD	build_v_may_defs
-#define FINALIZE_OPBUILD_ELEM(I)	opbuild_elem_virtual (&build_v_may_defs, (I))
-#define FINALIZE_OPBUILD_BASE(I)	opbuild_elem_uid (&build_v_may_defs, (I))
+#define FINALIZE_OPBUILD_ELEM(I)	VEC_index (tree, build_v_may_defs, (I))
+#define FINALIZE_OPBUILD_BASE(I)	get_name_decl (VEC_index (tree,	\
+							build_v_may_defs, (I)))
 #define FINALIZE_FUNC		finalize_ssa_v_may_def_ops
 #define FINALIZE_ALLOC		alloc_maydef
 #define FINALIZE_FREE		free_maydefs
@@ -617,8 +453,7 @@ finalize_ssa_uses (tree stmt)
 #define FINALIZE_USE_PTR(PTR)	MAYDEF_OP_PTR (PTR)
 #define FINALIZE_CORRECT_USE	set_virtual_use_link
 #define FINALIZE_BASE_ZERO	0
-#define FINALIZE_BASE(VAR)	((TREE_CODE (VAR) == SSA_NAME)		\
-				? DECL_UID (SSA_NAME_VAR (VAR)) : DECL_UID ((VAR)))
+#define FINALIZE_BASE(VAR)	get_name_decl (VAR)
 #define FINALIZE_BASE_TYPE	unsigned
 #define FINALIZE_INITIALIZE(PTR, VAL, STMT)				\
 				(PTR)->def_var = (VAL);			\
@@ -642,24 +477,25 @@ static inline void
 cleanup_v_may_defs (void)
 {
   unsigned x, num;
-  num = opbuild_num_elems (&build_v_may_defs);
+  num = VEC_length (tree, build_v_may_defs);
 
   for (x = 0; x < num; x++)
     {
-      tree t = opbuild_elem_virtual (&build_v_may_defs, x);
+      tree t = VEC_index (tree, build_v_may_defs, x);
       if (TREE_CODE (t) != SSA_NAME)
 	{
 	  var_ann_t ann = var_ann (t);
 	  ann->in_v_may_def_list = 0;
 	}
     }
-  opbuild_clear (&build_v_may_defs);
+  VEC_truncate (tree, build_v_may_defs, 0);
 }                                                                             
 
                                                                               
 #define FINALIZE_OPBUILD	build_vuses
-#define FINALIZE_OPBUILD_ELEM(I)	opbuild_elem_virtual (&build_vuses, (I))
-#define FINALIZE_OPBUILD_BASE(I)	opbuild_elem_uid (&build_vuses, (I))
+#define FINALIZE_OPBUILD_ELEM(I)	VEC_index (tree, build_vuses, (I))
+#define FINALIZE_OPBUILD_BASE(I)	get_name_decl (VEC_index (tree,	\
+							build_vuses, (I)))
 #define FINALIZE_FUNC		finalize_ssa_vuse_ops
 #define FINALIZE_ALLOC		alloc_vuse
 #define FINALIZE_FREE		free_vuses
@@ -669,8 +505,7 @@ cleanup_v_may_defs (void)
 #define FINALIZE_USE_PTR(PTR)	VUSE_OP_PTR (PTR)
 #define FINALIZE_CORRECT_USE	set_virtual_use_link
 #define FINALIZE_BASE_ZERO	0
-#define FINALIZE_BASE(VAR)	((TREE_CODE (VAR) == SSA_NAME)		\
-				? DECL_UID (SSA_NAME_VAR (VAR)) : DECL_UID ((VAR)))
+#define FINALIZE_BASE(VAR)	get_name_decl (VAR)
 #define FINALIZE_BASE_TYPE	unsigned
 #define FINALIZE_INITIALIZE(PTR, VAL, STMT)				\
 				(PTR)->use_var = (VAL);			\
@@ -686,7 +521,7 @@ static void
 finalize_ssa_vuses (tree stmt)
 {
   unsigned num, num_v_may_defs;
-  int vuse_index;
+  unsigned vuse_index;
 
   /* Remove superfluous VUSE operands.  If the statement already has a
    V_MAY_DEF operation for a variable 'a', then a VUSE for 'a' is not
@@ -700,39 +535,35 @@ finalize_ssa_vuses (tree stmt)
   The VUSE <a_2> is superfluous because it is implied by the V_MAY_DEF
   operation.  */
 
-  num = opbuild_num_elems (&build_vuses);
-  num_v_may_defs = opbuild_num_elems (&build_v_may_defs);
+  num = VEC_length (tree, build_vuses);
+  num_v_may_defs = VEC_length (tree, build_v_may_defs);
 
   if (num > 0 && num_v_may_defs > 0)
     {
-      int last = OPBUILD_LAST;
-      vuse_index = opbuild_first (&build_vuses);
-      for ( ; vuse_index != OPBUILD_LAST; )
+      for (vuse_index = 0; vuse_index < VEC_length (tree, build_vuses); )
         {
 	  tree vuse;
-	  vuse = opbuild_elem_virtual (&build_vuses, vuse_index);
+	  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_v_may_def_list)
 	        {
-		  vuse_index = opbuild_remove_elem (&build_vuses, vuse_index, 
-						    last);
+		  VEC_ordered_remove (tree, build_vuses, vuse_index);
 		  continue;
 		}
 	    }
-	  last = vuse_index;
-	  vuse_index = opbuild_next (&build_vuses, vuse_index);
+	  vuse_index++;
 	}
     }
   else
     /* Clear out the in_list bits.  */
-    for (vuse_index = opbuild_first (&build_vuses);
-	 vuse_index != OPBUILD_LAST;
-	 vuse_index = opbuild_next (&build_vuses, vuse_index))
+    for (vuse_index = 0;
+	 vuse_index < VEC_length (tree, build_vuses);
+	 vuse_index++)
       {
-	tree t = opbuild_elem_virtual (&build_vuses, vuse_index);
+	tree t = VEC_index (tree, build_vuses, vuse_index);
 	if (TREE_CODE (t) != SSA_NAME)
 	  {
 	    var_ann_t ann = var_ann (t);
@@ -745,15 +576,16 @@ finalize_ssa_vuses (tree stmt)
   cleanup_v_may_defs ();
                                                                               
   /* Free the vuses build vector.  */
-  opbuild_clear (&build_vuses);
+  VEC_truncate (tree, build_vuses, 0);
 
 }
                                                                               
 /* Return a new v_must_def operand vector for STMT, comparing to OLD_OPS_P.  */
                                                                               
 #define FINALIZE_OPBUILD	build_v_must_defs
-#define FINALIZE_OPBUILD_ELEM(I)	opbuild_elem_virtual (&build_v_must_defs, (I))
-#define FINALIZE_OPBUILD_BASE(I)	opbuild_elem_uid (&build_v_must_defs, (I))
+#define FINALIZE_OPBUILD_ELEM(I)	VEC_index (tree, build_v_must_defs, (I))
+#define FINALIZE_OPBUILD_BASE(I)	get_name_decl (VEC_index (tree,	\
+							build_v_must_defs, (I)))
 #define FINALIZE_FUNC		finalize_ssa_v_must_def_ops
 #define FINALIZE_ALLOC		alloc_mustdef
 #define FINALIZE_FREE		free_mustdefs
@@ -763,8 +595,7 @@ finalize_ssa_vuses (tree stmt)
 #define FINALIZE_USE_PTR(PTR)	MUSTDEF_KILL_PTR (PTR)
 #define FINALIZE_CORRECT_USE	set_virtual_use_link
 #define FINALIZE_BASE_ZERO	0
-#define FINALIZE_BASE(VAR)	((TREE_CODE (VAR) == SSA_NAME)		\
-				? DECL_UID (SSA_NAME_VAR (VAR)) : DECL_UID ((VAR)))
+#define FINALIZE_BASE(VAR)	get_name_decl (VAR)
 #define FINALIZE_BASE_TYPE	unsigned
 #define FINALIZE_INITIALIZE(PTR, VAL, STMT)				\
 				(PTR)->def_var = (VAL);			\
@@ -785,7 +616,7 @@ finalize_ssa_v_must_defs (tree stmt)
      having subvars, and have num >1, you have hit a bug. */
 
   finalize_ssa_v_must_def_ops (stmt);
-  opbuild_clear (&build_v_must_defs);
+  VEC_truncate (tree, build_v_must_defs, 0);
 }
 
 
@@ -807,11 +638,11 @@ finalize_ssa_stmt_operands (tree stmt)
 static inline void
 start_ssa_stmt_operands (void)
 {
-  gcc_assert (opbuild_num_elems (&build_defs) == 0);
-  gcc_assert (opbuild_num_elems (&build_uses) == 0);
-  gcc_assert (opbuild_num_elems (&build_vuses) == 0);
-  gcc_assert (opbuild_num_elems (&build_v_may_defs) == 0);
-  gcc_assert (opbuild_num_elems (&build_v_must_defs) == 0);
+  gcc_assert (VEC_length (tree, build_defs) == 0);
+  gcc_assert (VEC_length (tree, build_uses) == 0);
+  gcc_assert (VEC_length (tree, build_vuses) == 0);
+  gcc_assert (VEC_length (tree, build_v_may_defs) == 0);
+  gcc_assert (VEC_length (tree, build_v_must_defs) == 0);
 }
 
 
@@ -820,7 +651,7 @@ start_ssa_stmt_operands (void)
 static inline void
 append_def (tree *def_p)
 {
-  opbuild_append_real (&build_defs, def_p);
+  VEC_safe_push (tree, heap, build_defs, (tree)def_p);
 }
 
 
@@ -829,7 +660,7 @@ append_def (tree *def_p)
 static inline void
 append_use (tree *use_p)
 {
-  opbuild_append_real (&build_uses, use_p);
+  VEC_safe_push (tree, heap, build_uses, (tree)use_p);
 }
 
 
@@ -848,7 +679,7 @@ append_v_may_def (tree var)
       ann->in_v_may_def_list = 1;
     }
 
-  opbuild_append_virtual (&build_v_may_defs, var);
+  VEC_safe_push (tree, heap, build_v_may_defs, (tree)var);
 }
 
 
@@ -868,7 +699,7 @@ append_vuse (tree var)
       ann->in_vuse_list = 1;
     }
 
-  opbuild_append_virtual (&build_vuses, var);
+  VEC_safe_push (tree, heap, build_vuses, (tree)var);
 }
 
 
@@ -880,11 +711,11 @@ append_v_must_def (tree var)
   unsigned i;
 
   /* Don't allow duplicate entries.  */
-  for (i = 0; i < opbuild_num_elems (&build_v_must_defs); i++)
-    if (var == opbuild_elem_virtual (&build_v_must_defs, i))
+  for (i = 0; i < VEC_length (tree, build_v_must_defs); i++)
+    if (var == VEC_index (tree, build_v_must_defs, i))
       return;
 
-  opbuild_append_virtual (&build_v_must_defs, var);
+  VEC_safe_push (tree, heap, build_v_must_defs, (tree)var);
 }
 
 
@@ -1014,6 +845,9 @@ build_ssa_operands (tree stmt)
   start_ssa_stmt_operands ();
 
   parse_ssa_operands (stmt);
+  operand_build_sort_virtual (build_vuses);
+  operand_build_sort_virtual (build_v_may_defs);
+  operand_build_sort_virtual (build_v_must_defs);
 
   finalize_ssa_stmt_operands (stmt);
 }
@@ -1082,9 +916,9 @@ copy_virtual_operands (tree dest, tree src)
   FOR_EACH_SSA_TREE_OPERAND (t, src, iter, SSA_OP_VMUSTDEF)
     append_v_must_def (t);
 
-  if (opbuild_num_elems (&build_vuses) == 0
-      && opbuild_num_elems (&build_v_may_defs) == 0
-      && opbuild_num_elems (&build_v_must_defs) == 0)
+  if (VEC_length (tree, build_vuses) == 0
+      && VEC_length (tree, build_v_may_defs) == 0
+      && VEC_length (tree, build_v_must_defs) == 0)
     return;
 
   /* Now commit the virtual operands to this stmt.  */
@@ -1148,9 +982,9 @@ create_ssa_artficial_load_stmt (tree new_stmt, tree old_stmt)
   start_ssa_stmt_operands ();
   parse_ssa_operands (new_stmt);
 
-  for (x = 0; x < opbuild_num_elems (&build_vuses); x++)
+  for (x = 0; x < VEC_length (tree, build_vuses); x++)
     {
-      tree t = opbuild_elem_virtual (&build_vuses, x);
+      tree t = VEC_index (tree, build_vuses, x);
       if (TREE_CODE (t) != SSA_NAME)
 	{
 	  var_ann_t ann = var_ann (t);
@@ -1158,9 +992,9 @@ create_ssa_artficial_load_stmt (tree new_stmt, tree old_stmt)
 	}
     }
    
-  for (x = 0; x < opbuild_num_elems (&build_v_may_defs); x++)
+  for (x = 0; x < VEC_length (tree, build_v_may_defs); x++)
     {
-      tree t = opbuild_elem_virtual (&build_v_may_defs, x);
+      tree t = VEC_index (tree, build_v_may_defs, x);
       if (TREE_CODE (t) != SSA_NAME)
 	{
 	  var_ann_t ann = var_ann (t);
@@ -1168,9 +1002,9 @@ create_ssa_artficial_load_stmt (tree new_stmt, tree old_stmt)
 	}
     }
   /* Remove any virtual operands that were found.  */
-  opbuild_clear (&build_v_may_defs);
-  opbuild_clear (&build_v_must_defs);
-  opbuild_clear (&build_vuses);
+  VEC_truncate (tree, build_v_may_defs, 0);
+  VEC_truncate (tree, build_v_must_defs, 0);
+  VEC_truncate (tree, build_vuses, 0);
 
   /* For each VDEF on the original statement, we want to create a
      VUSE of the V_MAY_DEF result or V_MUST_DEF op on the new 
@@ -1972,7 +1806,6 @@ add_to_addressable_set (tree ref, bitmap *addresses_taken)
 static void
 add_call_clobber_ops (tree stmt, tree callee)
 {
-  int i;
   unsigned u;
   tree t;
   bitmap_iterator bi;
@@ -2010,21 +1843,19 @@ add_call_clobber_ops (tree stmt, tree callee)
       && (!not_read_b || bitmap_empty_p (not_read_b))
       && (!not_written_b || bitmap_empty_p (not_written_b)))
     {
-      /* Process the caches in reverse order so we are always inserting at
-         the head of the list.  */
-      for (i = VEC_length (tree, clobbered_vuses) - 1; i >=0; i--)
+      for (u = 0 ; u < VEC_length (tree, clobbered_vuses); u++)
 	{
-	  t = VEC_index (tree, clobbered_vuses, i);
+	  t = VEC_index (tree, clobbered_vuses, u);
 	  gcc_assert (TREE_CODE (t) != SSA_NAME);
 	  var_ann (t)->in_vuse_list = 1;
-	  opbuild_append_virtual (&build_vuses, t);
+	  VEC_safe_push (tree, heap, build_vuses, (tree)t);
 	}
-      for (i = VEC_length (tree, clobbered_v_may_defs) - 1; i >= 0; i--)
+      for (u = 0; u < VEC_length (tree, clobbered_v_may_defs); u++)
 	{
-	  t = VEC_index (tree, clobbered_v_may_defs, i);
+	  t = VEC_index (tree, clobbered_v_may_defs, u);
 	  gcc_assert (TREE_CODE (t) != SSA_NAME);
 	  var_ann (t)->in_v_may_def_list = 1;
-	  opbuild_append_virtual (&build_v_may_defs, t);
+	  VEC_safe_push (tree, heap, build_v_may_defs, (tree)t);
 	}
       if (s_ann)
 	{
@@ -2079,22 +1910,18 @@ add_call_clobber_ops (tree stmt, tree callee)
       VEC_truncate (tree, clobbered_v_may_defs, 0);
 
       /* Now fill the clobbered cache with the values that have been found.  */
-      for (i = opbuild_first (&build_vuses);
-	   i != OPBUILD_LAST;
-	   i = opbuild_next (&build_vuses, i))
+      for (u = 0; u < VEC_length (tree, build_vuses); u++)
 	VEC_safe_push (tree, heap, clobbered_vuses,
-		       opbuild_elem_virtual (&build_vuses, i));
+		       VEC_index (tree, build_vuses, u));
 
-      gcc_assert (opbuild_num_elems (&build_vuses) 
+      gcc_assert (VEC_length (tree, build_vuses) 
 		  == VEC_length (tree, clobbered_vuses));
 
-      for (i = opbuild_first (&build_v_may_defs);
-	   i != OPBUILD_LAST;
-	   i = opbuild_next (&build_v_may_defs, i))
+      for (u = 0; u < VEC_length (tree, build_v_may_defs); u++)
 	VEC_safe_push (tree, heap, clobbered_v_may_defs, 
-		       opbuild_elem_virtual (&build_v_may_defs, i));
+		       VEC_index (tree, build_v_may_defs, u));
 
-      gcc_assert (opbuild_num_elems (&build_v_may_defs) 
+      gcc_assert (VEC_length (tree, build_v_may_defs) 
 		  == VEC_length (tree, clobbered_v_may_defs));
 
       ssa_call_clobbered_cache_valid = true;
@@ -2108,7 +1935,6 @@ add_call_clobber_ops (tree stmt, tree callee)
 static void
 add_call_read_ops (tree stmt)
 {
-  int i;
   unsigned u;
   tree t;
   bitmap_iterator bi;
@@ -2127,14 +1953,12 @@ add_call_read_ops (tree stmt)
   /* If cache is valid, copy the elements into the build vector.  */
   if (ssa_ro_call_cache_valid)
     {
-      for (i = VEC_length (tree, ro_call_vuses) - 1; i >=0 ; i--)
+      for (u = 0; u < VEC_length (tree, ro_call_vuses); u++)
 	{
-	  /* Process the caches in reverse order so we are always inserting at
-	     the head of the list.  */
-	  t = VEC_index (tree, ro_call_vuses, i);
+	  t = VEC_index (tree, ro_call_vuses, u);
 	  gcc_assert (TREE_CODE (t) != SSA_NAME);
 	  var_ann (t)->in_vuse_list = 1;
-	  opbuild_append_virtual (&build_vuses, t);
+	  VEC_safe_push (tree, heap, build_vuses, (tree)t);
 	}
       if (s_ann)
 	s_ann->makes_aliased_loads = ro_call_aliased_loads;
@@ -2158,13 +1982,11 @@ add_call_read_ops (tree stmt)
   VEC_truncate (tree, ro_call_vuses, 0);
 
   /* Now fill the clobbered cache with the values that have been found.  */
-  for (i = opbuild_first (&build_vuses);
-       i != OPBUILD_LAST;
-       i = opbuild_next (&build_vuses, i))
+  for (u = 0; u <  VEC_length (tree, build_vuses); u++)
     VEC_safe_push (tree, heap, ro_call_vuses,
-		   opbuild_elem_virtual (&build_vuses, i));
+		   VEC_index (tree, build_vuses, u));
 
-  gcc_assert (opbuild_num_elems (&build_vuses) 
+  gcc_assert (VEC_length (tree, build_vuses) 
 	      == VEC_length (tree, ro_call_vuses));
 
   ssa_ro_call_cache_valid = true;
diff --git a/gcc/tree-ssa-opfinalize.h b/gcc/tree-ssa-opfinalize.h
index f58c93f3a19..cc48e9ed742 100644
--- a/gcc/tree-ssa-opfinalize.h
+++ b/gcc/tree-ssa-opfinalize.h
@@ -63,7 +63,7 @@ FINALIZE_ALLOC (void)
 static inline void
 FINALIZE_FUNC (tree stmt)
 {
-  int new_i;
+  unsigned new_i;
   FINALIZE_TYPE *old_ops, *ptr, *last;
   FINALIZE_BASE_TYPE old_base;
   FINALIZE_TYPE new_list;
@@ -77,8 +77,8 @@ FINALIZE_FUNC (tree stmt)
   else
     old_base = FINALIZE_BASE_ZERO;
 
-  new_i = opbuild_first (&FINALIZE_OPBUILD);
-  while (old_ops && new_i != OPBUILD_LAST)
+  new_i = 0;
+  while (old_ops && new_i < VEC_length (tree, FINALIZE_OPBUILD))
     {
       FINALIZE_BASE_TYPE new_base = FINALIZE_OPBUILD_BASE (new_i);
       if (old_base == new_base)
@@ -90,7 +90,7 @@ FINALIZE_FUNC (tree stmt)
 	  FINALIZE_CORRECT_USE (FINALIZE_USE_PTR (last), stmt);
 #endif
 	  old_ops = old_ops->next;
-	  new_i = opbuild_next (&FINALIZE_OPBUILD, new_i);
+	  new_i++;
 	}
       else
         if (old_base < new_base)
@@ -112,16 +112,14 @@ FINALIZE_FUNC (tree stmt)
 	    FINALIZE_INITIALIZE (ptr, FINALIZE_OPBUILD_ELEM (new_i), stmt);
 	    last->next = ptr;
 	    last = ptr;
-	    new_i = opbuild_next (&FINALIZE_OPBUILD, new_i);
+	    new_i++;
 	  }
       if (old_ops)
         old_base = FINALIZE_BASE (FINALIZE_ELEM (old_ops));
     }
 
   /* If there is anything remaining in the opbuild list, simply emit them.  */
-  for ( ; 
-	new_i != OPBUILD_LAST; 
-	new_i = opbuild_next (&FINALIZE_OPBUILD, new_i))
+  for ( ; new_i < VEC_length (tree, FINALIZE_OPBUILD); new_i++)
     {
       ptr = FINALIZE_ALLOC ();
       FINALIZE_INITIALIZE (ptr, FINALIZE_OPBUILD_ELEM (new_i), stmt);
@@ -154,7 +152,7 @@ FINALIZE_FUNC (tree stmt)
     for (ptr = FINALIZE_OPS (stmt); ptr; ptr = ptr->next)
       x++;
 
-    gcc_assert (x == opbuild_num_elems (&FINALIZE_OPBUILD));
+    gcc_assert (x == VEC_length (tree, FINALIZE_OPBUILD));
   }
 #endif
 }