mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-03-15 11:31:19 +08:00
Code Issues Packages Projects Releases Wiki Activity

re PR tree-optimization/18587 (build_v_may_defs and build_vuses can be improved when adding)

Browse Source 
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.

From-SVN: r104996
This commit is contained in:
Andrew MacLeod 2005-10-05 15:16:42 +00:00 committed by Andrew Macleod
parent 3015564c8a
commit f3940b0e3d
3 changed files with 172 additions and 324 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
gcc/ChangeLog
View File

@ -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

452
gcc/tree-ssa-operands.c
View File

@ -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 <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;

16
gcc/tree-ssa-opfinalize.h
View File

@ -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
}