From f3940b0e3d26190dbcfe86f0bc5f4a84b259c298 Mon Sep 17 00:00:00 2001 From: Andrew MacLeod Date: Wed, 5 Oct 2005 15:16:42 +0000 Subject: [PATCH] re PR tree-optimization/18587 (build_v_may_defs and build_vuses can be improved when adding) 2005-10-05 Andrew MacLeod 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. From-SVN: r104996 --- gcc/ChangeLog | 28 +++ gcc/tree-ssa-operands.c | 452 ++++++++++++-------------------------- gcc/tree-ssa-opfinalize.h | 16 +- 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 + + 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 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++; + /* There are 3 or more elements, call qsort. */ + qsort (VEC_address (tree, list), + VEC_length (tree, list), + sizeof (tree), + operand_build_cmp); } -/* 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); -} - - -/* 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 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 }