Skip to content

R
riscv-gcc-1
Commit 4c124b4c by Andrew MacLeod Committed by Andrew Macleod
Options

tree-ssa-operands.h (struct ssa_operand_iterator_d): New. 


2004-08-25  Andrew MacLeod  <amacleod@redhat.com>

	* tree-ssa-operands.h (struct ssa_operand_iterator_d): New.  SSA operand
	iterator controlling structure.
	(SSA_OP_USE, SSA_OP_DEF, SSA_OP_VUSE, SSA_OP_VMAYUSE, SSA_OP_VMAYDEF,
	SSA_OP_VMUSTDEF, SSA_OP_VIRTUAL_USES, SSA_OP_VIRTUAL_DEFS,
	SSA_OP_ALL_USES, SSA_OP_ALL_DEFS, SSA_OP_ALL_OPERANDS): New.  Operand
	iterator flags.
	(FOR_EACH_SSA_TREE_OPERAND): New.  Iterate over operands as trees.
	(FOR_EACH_SSA_USE_OPERAND): New.  Iterate over operands as uses.
	(FOR_EACH_SSA_DEF_OPERAND): New.  Iterate over operands as defs.
	(FOR_EACH_SSA_MAYDEF_OPERAND): New.  Iterate over V_MAY_DEFs.
	* tree-ssa-operands.c (NULL_DEF_OPERAND_P, NULL_USE_OPERAND_P): New.
	Empty operand pointers.
	* tree-flow-inline.h (op_iter_done): New.  Return true if finished.
	(op_iter_next_use): New.  Return next use_operand_p.
	(op_iter_next_def): New.  Return next def_operand_p.
	(op_iter_next_tree): New.  Return next operands as a tree.
	(op_iter_init): New.  Initialize an iterator structure.
	(op_iter_init_use): New.  Initialize structure and get the first use.
	(op_iter_init_def): New.  Initialize structure and get the first def.
	(op_iter_init_tree): New.  Initialize structure and get the first tree.
	(op_iter_next_maydef): New.  Return next V_MAY_DEF operands.
	(op_iter_init_maydef): New.  Initialize structure and get the first
	V_MAY_DEF operands.
	* tree-cfg.c (tree_duplicate_bb): Use new operand iterator.
	* tree-dfa.c (compute_immediate_uses_for_stmt,
	redirect_immediate_uses): Use new operand iterator.
	(v_may_defs_disappeared_p, v_must_defs_disappeared_p): Delete.
	(mark_new_vars_to_rename): Use new operand iterator.  Count virtual
	operands instead of using *_disappeared_p routines.
	* tree-into-ssa.c (mark_def_sites, ssa_mark_def_sites, rewrite_stmt,
	ssa_rewrite_stmt): Use new operand iterator.
	* tree-outof-ssa.c (check_replaceable, find_replaceable_in_bb,
	rewrite_trees): Use new operand iterator.
	* tree-pretty-print.c (dump_vops): Use new operand iterator.
	* tree-sra.c (mark_all_v_defs): Use new operand iterator.
	* tree-ssa-alias.c (compute_points_to_and_addr_escape,
	dump_points_to_info): Use new operand iterator.
	* tree-ssa-ccp.c (cp_lattice_meet, visit_stmt, initialize,
	replace_uses_in, replace_vuse_in, likely_value, set_rhs): Use new
	operand iterator.
	* tree-ssa-dce.c (mark_stmt_if_obviously_necessary,
	propagate_necessity): Use new operand iterator.
	* tree-ssa-dom.c (cprop_into_stmt, optimize_stmt): Use operand iterator.
	(register_definitions_for_stmt): Use new operand iterator.  Take stmt as
	a parameter instead of a stmt_ann_t.
	* tree-ssa-live.c (create_ssa_var_map, calculate_live_on_entry,
	build_tree_conflict_graph): Use new operand iterator.
	* tree-ssa-loop-im.c (determine_max_movement, single_reachable_address,
	rewrite_mem_refs): Use new operand iterator.
	* tree-ssa-loop-manip.c (find_uses_to_rename_stmt,
	check_loop_closed_ssa_use): Use new operand iterator.
	* tree-ssa.c (verify_ssa, replace_immediate_uses): Use operand iterator.
	* tree-ssanames.c (release_defs): Use new operand iterator.
	* tree-vectorizer.c (vect_create_data_ref): Use new operand iterator.

From-SVN: r86583
parent 75101feb
Showing with 483 additions and 635 deletions
gcc/ChangeLog
2004-08-25 Andrew MacLeod <amacleod@redhat.com>
* tree-ssa-operands.h (struct ssa_operand_iterator_d): New. SSA operand
iterator controlling structure.
(SSA_OP_USE, SSA_OP_DEF, SSA_OP_VUSE, SSA_OP_VMAYUSE, SSA_OP_VMAYDEF,
SSA_OP_VMUSTDEF, SSA_OP_VIRTUAL_USES, SSA_OP_VIRTUAL_DEFS,
SSA_OP_ALL_USES, SSA_OP_ALL_DEFS, SSA_OP_ALL_OPERANDS): New. Operand
iterator flags.
(FOR_EACH_SSA_TREE_OPERAND): New. Iterate over operands as trees.
(FOR_EACH_SSA_USE_OPERAND): New. Iterate over operands as uses.
(FOR_EACH_SSA_DEF_OPERAND): New. Iterate over operands as defs.
(FOR_EACH_SSA_MAYDEF_OPERAND): New. Iterate over V_MAY_DEFs.
* tree-ssa-operands.c (NULL_DEF_OPERAND_P, NULL_USE_OPERAND_P): New.
Empty operand pointers.
* tree-flow-inline.h (op_iter_done): New. Return true if finished.
(op_iter_next_use): New. Return next use_operand_p.
(op_iter_next_def): New. Return next def_operand_p.
(op_iter_next_tree): New. Return next operands as a tree.
(op_iter_init): New. Initialize an iterator structure.
(op_iter_init_use): New. Initialize structure and get the first use.
(op_iter_init_def): New. Initialize structure and get the first def.
(op_iter_init_tree): New. Initialize structure and get the first tree.
(op_iter_next_maydef): New. Return next V_MAY_DEF operands.
(op_iter_init_maydef): New. Initialize structure and get the first
V_MAY_DEF operands.
* tree-cfg.c (tree_duplicate_bb): Use new operand iterator.
* tree-dfa.c (compute_immediate_uses_for_stmt,
redirect_immediate_uses): Use new operand iterator.
(v_may_defs_disappeared_p, v_must_defs_disappeared_p): Delete.
(mark_new_vars_to_rename): Use new operand iterator. Count virtual
operands instead of using *_disappeared_p routines.
* tree-into-ssa.c (mark_def_sites, ssa_mark_def_sites, rewrite_stmt,
ssa_rewrite_stmt): Use new operand iterator.
* tree-outof-ssa.c (check_replaceable, find_replaceable_in_bb,
rewrite_trees): Use new operand iterator.
* tree-pretty-print.c (dump_vops): Use new operand iterator.
* tree-sra.c (mark_all_v_defs): Use new operand iterator.
* tree-ssa-alias.c (compute_points_to_and_addr_escape,
dump_points_to_info): Use new operand iterator.
* tree-ssa-ccp.c (cp_lattice_meet, visit_stmt, initialize,
replace_uses_in, replace_vuse_in, likely_value, set_rhs): Use new
operand iterator.
* tree-ssa-dce.c (mark_stmt_if_obviously_necessary,
propagate_necessity): Use new operand iterator.
* tree-ssa-dom.c (cprop_into_stmt, optimize_stmt): Use operand iterator.
(register_definitions_for_stmt): Use new operand iterator. Take stmt as
a parameter instead of a stmt_ann_t.
* tree-ssa-live.c (create_ssa_var_map, calculate_live_on_entry,
build_tree_conflict_graph): Use new operand iterator.
* tree-ssa-loop-im.c (determine_max_movement, single_reachable_address,
rewrite_mem_refs): Use new operand iterator.
* tree-ssa-loop-manip.c (find_uses_to_rename_stmt,
check_loop_closed_ssa_use): Use new operand iterator.
* tree-ssa.c (verify_ssa, replace_immediate_uses): Use operand iterator.
* tree-ssanames.c (release_defs): Use new operand iterator.
* tree-vectorizer.c (vect_create_data_ref): Use new operand iterator.
2004-08-25 Adam Nemet <anemet@lnxw.com> 2004-08-25 Adam Nemet <anemet@lnxw.com>
* tlink.c (initial_cwd): New variable. * tlink.c (initial_cwd): New variable.
......
gcc/tree-cfg.c
...@@ -4245,11 +4245,8 @@ tree_duplicate_bb (basic_block bb) ...@@ -4245,11 +4245,8 @@ tree_duplicate_bb (basic_block bb)
{ {
basic_block new_bb; basic_block new_bb;
block_stmt_iterator bsi, bsi_tgt; block_stmt_iterator bsi, bsi_tgt;
tree phi; tree phi, val;
def_optype defs; ssa_op_iter op_iter;
v_may_def_optype v_may_defs;
v_must_def_optype v_must_defs;
unsigned j;
new_bb = create_empty_bb (EXIT_BLOCK_PTR->prev_bb); new_bb = create_empty_bb (EXIT_BLOCK_PTR->prev_bb);
...@@ -4270,17 +4267,8 @@ tree_duplicate_bb (basic_block bb) ...@@ -4270,17 +4267,8 @@ tree_duplicate_bb (basic_block bb)
/* Record the definitions. */ /* Record the definitions. */
get_stmt_operands (stmt); get_stmt_operands (stmt);
defs = STMT_DEF_OPS (stmt); FOR_EACH_SSA_TREE_OPERAND (val, stmt, op_iter, SSA_OP_ALL_DEFS)
for (j = 0; j < NUM_DEFS (defs); j++) mark_for_rewrite (val);
mark_for_rewrite (DEF_OP (defs, j));
v_may_defs = STMT_V_MAY_DEF_OPS (stmt);
for (j = 0; j < NUM_V_MAY_DEFS (v_may_defs); j++)
mark_for_rewrite (V_MAY_DEF_RESULT (v_may_defs, j));
v_must_defs = STMT_V_MUST_DEF_OPS (stmt);
for (j = 0; j < NUM_V_MUST_DEFS (v_must_defs); j++)
mark_for_rewrite (V_MUST_DEF_OP (v_must_defs, j));
copy = unshare_expr (stmt); copy = unshare_expr (stmt);
......
gcc/tree-dfa.c
...@@ -270,11 +270,8 @@ compute_immediate_uses_for_phi (tree phi, bool (*calc_for)(tree)) ...@@ -270,11 +270,8 @@ compute_immediate_uses_for_phi (tree phi, bool (*calc_for)(tree))
static void static void
compute_immediate_uses_for_stmt (tree stmt, int flags, bool (*calc_for)(tree)) compute_immediate_uses_for_stmt (tree stmt, int flags, bool (*calc_for)(tree))
{ {
size_t i; tree use;
use_optype uses; ssa_op_iter iter;
vuse_optype vuses;
v_may_def_optype v_may_defs;
stmt_ann_t ann;
#ifdef ENABLE_CHECKING #ifdef ENABLE_CHECKING
/* PHI nodes are handled elsewhere. */ /* PHI nodes are handled elsewhere. */
...@@ -283,13 +280,10 @@ compute_immediate_uses_for_stmt (tree stmt, int flags, bool (*calc_for)(tree)) ...@@ -283,13 +280,10 @@ compute_immediate_uses_for_stmt (tree stmt, int flags, bool (*calc_for)(tree))
#endif #endif
/* Look at USE_OPS or VUSE_OPS according to FLAGS. */ /* Look at USE_OPS or VUSE_OPS according to FLAGS. */
ann = stmt_ann (stmt);
if (flags & TDFA_USE_OPS) if (flags & TDFA_USE_OPS)
{ {
uses = USE_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE)
for (i = 0; i < NUM_USES (uses); i++)
{ {
tree use = USE_OP (uses, i);
tree imm_stmt = SSA_NAME_DEF_STMT (use); tree imm_stmt = SSA_NAME_DEF_STMT (use);
if (!IS_EMPTY_STMT (imm_stmt) && (!calc_for || calc_for (use))) if (!IS_EMPTY_STMT (imm_stmt) && (!calc_for || calc_for (use)))
add_immediate_use (imm_stmt, stmt); add_immediate_use (imm_stmt, stmt);
...@@ -298,21 +292,10 @@ compute_immediate_uses_for_stmt (tree stmt, int flags, bool (*calc_for)(tree)) ...@@ -298,21 +292,10 @@ compute_immediate_uses_for_stmt (tree stmt, int flags, bool (*calc_for)(tree))
if (flags & TDFA_USE_VOPS) if (flags & TDFA_USE_VOPS)
{ {
vuses = VUSE_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_VIRTUAL_USES)
for (i = 0; i < NUM_VUSES (vuses); i++)
{ {
tree vuse = VUSE_OP (vuses, i); tree imm_rdef_stmt = SSA_NAME_DEF_STMT (use);
tree imm_rdef_stmt = SSA_NAME_DEF_STMT (vuse); if (!IS_EMPTY_STMT (imm_rdef_stmt) && (!calc_for || calc_for (use)))
if (!IS_EMPTY_STMT (imm_rdef_stmt) && (!calc_for || calc_for (vuse)))
add_immediate_use (imm_rdef_stmt, stmt);
}
v_may_defs = V_MAY_DEF_OPS (ann);
for (i = 0; i < NUM_V_MAY_DEFS (v_may_defs); i++)
{
tree vuse = V_MAY_DEF_OP (v_may_defs, i);
tree imm_rdef_stmt = SSA_NAME_DEF_STMT (vuse);
if (!IS_EMPTY_STMT (imm_rdef_stmt) && (!calc_for || calc_for (vuse)))
add_immediate_use (imm_rdef_stmt, stmt); add_immediate_use (imm_rdef_stmt, stmt);
} }
} }
...@@ -380,21 +363,11 @@ redirect_immediate_use (tree use, tree old, tree new) ...@@ -380,21 +363,11 @@ redirect_immediate_use (tree use, tree old, tree new)
void void
redirect_immediate_uses (tree old, tree new) redirect_immediate_uses (tree old, tree new)
{ {
stmt_ann_t ann = get_stmt_ann (old); ssa_op_iter iter;
use_optype uses = USE_OPS (ann); tree val;
vuse_optype vuses = VUSE_OPS (ann);
v_may_def_optype v_may_defs = V_MAY_DEF_OPS (ann);
unsigned int i;
/* Look at USE_OPS or VUSE_OPS according to FLAGS. */ FOR_EACH_SSA_TREE_OPERAND (val, old, iter, SSA_OP_ALL_USES)
for (i = 0; i < NUM_USES (uses); i++) redirect_immediate_use (val, old, new);
redirect_immediate_use (USE_OP (uses, i), old, new);
for (i = 0; i < NUM_VUSES (vuses); i++)
redirect_immediate_use (VUSE_OP (vuses, i), old, new);
for (i = 0; i < NUM_V_MAY_DEFS (v_may_defs); i++)
redirect_immediate_use (V_MAY_DEF_OP (v_may_defs, i), old, new);
} }
...@@ -956,48 +929,6 @@ add_referenced_tmp_var (tree var) ...@@ -956,48 +929,6 @@ add_referenced_tmp_var (tree var)
add_referenced_var (var, NULL); add_referenced_var (var, NULL);
} }
/* Return true if V_MAY_DEFS_AFTER contains fewer entries than
V_MAY_DEFS_BEFORE. Note that this assumes that both varrays
are V_MAY_DEF operands for the same statement. */
static inline bool
v_may_defs_disappeared_p (v_may_def_optype v_may_defs_before,
v_may_def_optype v_may_defs_after)
{
/* If there was nothing before, nothing could've disappeared. */
if (v_may_defs_before == NULL)
return false;
/* All/some of them gone. */
if (v_may_defs_after == NULL
|| NUM_V_MAY_DEFS (v_may_defs_before) >
NUM_V_MAY_DEFS (v_may_defs_after))
return true;
return false;
}
/* Return true if V_MUST_DEFS_AFTER contains fewer entries than
V_MUST_DEFS_BEFORE. Note that this assumes that both varrays
are V_MUST_DEF operands for the same statement. */
static inline bool
v_must_defs_disappeared_p (v_must_def_optype v_must_defs_before,
v_must_def_optype v_must_defs_after)
{
/* If there was nothing before, nothing could've disappeared. */
if (v_must_defs_before == NULL)
return false;
/* All/some of them gone. */
if (v_must_defs_after == NULL
|| NUM_V_MUST_DEFS (v_must_defs_before) >
NUM_V_MUST_DEFS (v_must_defs_after))
return true;
return false;
}
/* Add all the non-SSA variables found in STMT's operands to the bitmap /* Add all the non-SSA variables found in STMT's operands to the bitmap
VARS_TO_RENAME. */ VARS_TO_RENAME. */
...@@ -1005,17 +936,12 @@ v_must_defs_disappeared_p (v_must_def_optype v_must_defs_before, ...@@ -1005,17 +936,12 @@ v_must_defs_disappeared_p (v_must_def_optype v_must_defs_before,
void void
mark_new_vars_to_rename (tree stmt, bitmap vars_to_rename) mark_new_vars_to_rename (tree stmt, bitmap vars_to_rename)
{ {
def_optype defs; ssa_op_iter iter;
use_optype uses; tree val;
v_may_def_optype v_may_defs;
vuse_optype vuses;
v_must_def_optype v_must_defs;
size_t i;
bitmap vars_in_vops_to_rename; bitmap vars_in_vops_to_rename;
bool found_exposed_symbol = false; bool found_exposed_symbol = false;
v_may_def_optype v_may_defs_before, v_may_defs_after; int v_may_defs_before, v_may_defs_after;
v_must_def_optype v_must_defs_before, v_must_defs_after; int v_must_defs_before, v_must_defs_after;
stmt_ann_t ann;
vars_in_vops_to_rename = BITMAP_XMALLOC (); vars_in_vops_to_rename = BITMAP_XMALLOC ();
...@@ -1028,32 +954,15 @@ mark_new_vars_to_rename (tree stmt, bitmap vars_to_rename) ...@@ -1028,32 +954,15 @@ mark_new_vars_to_rename (tree stmt, bitmap vars_to_rename)
We flag them in a separate bitmap because we don't really want to We flag them in a separate bitmap because we don't really want to
rename them if there are not any newly exposed symbols in the rename them if there are not any newly exposed symbols in the
statement operands. */ statement operands. */
ann = stmt_ann (stmt); v_may_defs_before = NUM_V_MAY_DEFS (STMT_V_MAY_DEF_OPS (stmt));
v_may_defs_before = v_may_defs = V_MAY_DEF_OPS (ann); v_must_defs_before = NUM_V_MUST_DEFS (STMT_V_MUST_DEF_OPS (stmt));
for (i = 0; i < NUM_V_MAY_DEFS (v_may_defs); i++)
{
tree var = V_MAY_DEF_RESULT (v_may_defs, i);
if (!DECL_P (var))
var = SSA_NAME_VAR (var);
bitmap_set_bit (vars_in_vops_to_rename, var_ann (var)->uid);
}
vuses = VUSE_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter,
for (i = 0; i < NUM_VUSES (vuses); i++) SSA_OP_VMAYDEF | SSA_OP_VUSE | SSA_OP_VMUSTDEF)
{ {
tree var = VUSE_OP (vuses, i); if (!DECL_P (val))
if (!DECL_P (var)) val = SSA_NAME_VAR (val);
var = SSA_NAME_VAR (var); bitmap_set_bit (vars_in_vops_to_rename, var_ann (val)->uid);
bitmap_set_bit (vars_in_vops_to_rename, var_ann (var)->uid);
}
v_must_defs_before = v_must_defs = V_MUST_DEF_OPS (ann);
for (i = 0; i < NUM_V_MUST_DEFS (v_must_defs); i++)
{
tree var = V_MUST_DEF_OP (v_must_defs, i);
if (!DECL_P (var))
var = SSA_NAME_VAR (var);
bitmap_set_bit (vars_in_vops_to_rename, var_ann (var)->uid);
} }
/* Now force an operand re-scan on the statement and mark any newly /* Now force an operand re-scan on the statement and mark any newly
...@@ -1061,58 +970,17 @@ mark_new_vars_to_rename (tree stmt, bitmap vars_to_rename) ...@@ -1061,58 +970,17 @@ mark_new_vars_to_rename (tree stmt, bitmap vars_to_rename)
modify_stmt (stmt); modify_stmt (stmt);
get_stmt_operands (stmt); get_stmt_operands (stmt);
defs = DEF_OPS (ann); v_may_defs_after = NUM_V_MAY_DEFS (STMT_V_MAY_DEF_OPS (stmt));
for (i = 0; i < NUM_DEFS (defs); i++) v_must_defs_after = NUM_V_MUST_DEFS (STMT_V_MUST_DEF_OPS (stmt));
{
tree var = DEF_OP (defs, i);
if (DECL_P (var))
{
found_exposed_symbol = true;
bitmap_set_bit (vars_to_rename, var_ann (var)->uid);
}
}
uses = USE_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter,
for (i = 0; i < NUM_USES (uses); i++) SSA_OP_VMAYDEF | SSA_OP_VUSE | SSA_OP_VMUSTDEF)
{
tree var = USE_OP (uses, i);
if (DECL_P (var))
{
found_exposed_symbol = true;
bitmap_set_bit (vars_to_rename, var_ann (var)->uid);
}
}
v_may_defs_after = v_may_defs = V_MAY_DEF_OPS (ann);
for (i = 0; i < NUM_V_MAY_DEFS (v_may_defs); i++)
{
tree var = V_MAY_DEF_RESULT (v_may_defs, i);
if (DECL_P (var))
{
found_exposed_symbol = true;
bitmap_set_bit (vars_to_rename, var_ann (var)->uid);
}
}
vuses = VUSE_OPS (ann);
for (i = 0; i < NUM_VUSES (vuses); i++)
{
tree var = VUSE_OP (vuses, i);
if (DECL_P (var))
{
found_exposed_symbol = true;
bitmap_set_bit (vars_to_rename, var_ann (var)->uid);
}
}
v_must_defs_after = v_must_defs = V_MUST_DEF_OPS (ann);
for (i = 0; i < NUM_V_MUST_DEFS (v_must_defs); i++)
{ {
tree var = V_MUST_DEF_OP (v_must_defs, i); if (DECL_P (val))
if (DECL_P (var))
{ {
found_exposed_symbol = true; found_exposed_symbol = true;
bitmap_set_bit (vars_to_rename, var_ann (var)->uid); bitmap_set_bit (vars_to_rename, var_ann (val)->uid);
} }
} }
...@@ -1122,8 +990,8 @@ mark_new_vars_to_rename (tree stmt, bitmap vars_to_rename) ...@@ -1122,8 +990,8 @@ mark_new_vars_to_rename (tree stmt, bitmap vars_to_rename)
vanishing VDEFs because in those cases, the names that were formerly vanishing VDEFs because in those cases, the names that were formerly
generated by this statement are not going to be available anymore. */ generated by this statement are not going to be available anymore. */
if (found_exposed_symbol if (found_exposed_symbol
|| v_may_defs_disappeared_p (v_may_defs_before, v_may_defs_after) || v_may_defs_before > v_may_defs_after
|| v_must_defs_disappeared_p (v_must_defs_before, v_must_defs_after)) || v_must_defs_before > v_must_defs_after)
bitmap_a_or_b (vars_to_rename, vars_to_rename, vars_in_vops_to_rename); bitmap_a_or_b (vars_to_rename, vars_to_rename, vars_in_vops_to_rename);
BITMAP_XFREE (vars_in_vops_to_rename); BITMAP_XFREE (vars_in_vops_to_rename);
......
gcc/tree-flow-inline.h
...@@ -673,4 +673,176 @@ get_tree_ann (tree t) ...@@ -673,4 +673,176 @@ get_tree_ann (tree t)
return (ann) ? ann : create_tree_ann (t); return (ann) ? ann : create_tree_ann (t);
} }
/* ----------------------------------------------------------------------- */
/* The following set of routines are used to iterator over various type of
SSA operands. */
/* Return true if PTR is finished iterating. */
static inline bool
op_iter_done (ssa_op_iter *ptr)
{
return ptr->done;
}
/* Get the next iterator use value for PTR. */
static inline use_operand_p
op_iter_next_use (ssa_op_iter *ptr)
{
if (ptr->use_i < ptr->num_use)
{
return USE_OP_PTR (ptr->ops->use_ops, (ptr->use_i)++);
}
if (ptr->vuse_i < ptr->num_vuse)
{
return VUSE_OP_PTR (ptr->ops->vuse_ops, (ptr->vuse_i)++);
}
if (ptr->v_mayu_i < ptr->num_v_mayu)
{
return V_MAY_DEF_OP_PTR (ptr->ops->v_may_def_ops,
(ptr->v_mayu_i)++);
}
ptr->done = true;
return NULL_USE_OPERAND_P;
}
/* Get the next iterator def value for PTR. */
static inline def_operand_p
op_iter_next_def (ssa_op_iter *ptr)
{
if (ptr->def_i < ptr->num_def)
{
return DEF_OP_PTR (ptr->ops->def_ops, (ptr->def_i)++);
}
if (ptr->v_must_i < ptr->num_v_must)
{
return V_MUST_DEF_OP_PTR (ptr->ops->v_must_def_ops,
(ptr->v_must_i)++);
}
if (ptr->v_mayd_i < ptr->num_v_mayd)
{
return V_MAY_DEF_RESULT_PTR (ptr->ops->v_may_def_ops,
(ptr->v_mayd_i)++);
}
ptr->done = true;
return NULL_DEF_OPERAND_P;
}
/* Get the next iterator tree value for PTR. */
static inline tree
op_iter_next_tree (ssa_op_iter *ptr)
{
if (ptr->use_i < ptr->num_use)
{
return USE_OP (ptr->ops->use_ops, (ptr->use_i)++);
}
if (ptr->vuse_i < ptr->num_vuse)
{
return VUSE_OP (ptr->ops->vuse_ops, (ptr->vuse_i)++);
}
if (ptr->v_mayu_i < ptr->num_v_mayu)
{
return V_MAY_DEF_OP (ptr->ops->v_may_def_ops, (ptr->v_mayu_i)++);
}
if (ptr->def_i < ptr->num_def)
{
return DEF_OP (ptr->ops->def_ops, (ptr->def_i)++);
}
if (ptr->v_must_i < ptr->num_v_must)
{
return V_MUST_DEF_OP (ptr->ops->v_must_def_ops,
(ptr->v_must_i)++);
}
if (ptr->v_mayd_i < ptr->num_v_mayd)
{
return V_MAY_DEF_RESULT (ptr->ops->v_may_def_ops,
(ptr->v_mayd_i)++);
}
ptr->done = true;
return NULL;
}
/* Initialize the iterator PTR to the virtual defs in STMT. */
static inline void
op_iter_init (ssa_op_iter *ptr, tree stmt, int flags)
{
stmt_operands_p ops;
stmt_ann_t ann = get_stmt_ann (stmt);
ops = &(ann->operands);
ptr->done = false;
ptr->ops = ops;
ptr->num_def = (flags & SSA_OP_DEF) ? NUM_DEFS (ops->def_ops) : 0;
ptr->num_use = (flags & SSA_OP_USE) ? NUM_USES (ops->use_ops) : 0;
ptr->num_vuse = (flags & SSA_OP_VUSE) ? NUM_VUSES (ops->vuse_ops) : 0;
ptr->num_v_mayu = (flags & SSA_OP_VMAYUSE)
? NUM_V_MAY_DEFS (ops->v_may_def_ops) : 0;
ptr->num_v_mayd = (flags & SSA_OP_VMAYDEF)
? NUM_V_MAY_DEFS (ops->v_may_def_ops) : 0;
ptr->num_v_must = (flags & SSA_OP_VMUSTDEF)
? NUM_V_MUST_DEFS (ops->v_must_def_ops) : 0;
ptr->def_i = 0;
ptr->use_i = 0;
ptr->vuse_i = 0;
ptr->v_mayu_i = 0;
ptr->v_mayd_i = 0;
ptr->v_must_i = 0;
}
/* Initialize iterator PTR to the use operands in STMT based on FLAGS. Return
the first use. */
static inline use_operand_p
op_iter_init_use (ssa_op_iter *ptr, tree stmt, int flags)
{
op_iter_init (ptr, stmt, flags);
return op_iter_next_use (ptr);
}
/* Initialize iterator PTR to the def operands in STMT based on FLAGS. Return
the first def. */
static inline def_operand_p
op_iter_init_def (ssa_op_iter *ptr, tree stmt, int flags)
{
op_iter_init (ptr, stmt, flags);
return op_iter_next_def (ptr);
}
/* Initialize iterator PTR to the operands in STMT based on FLAGS. Return
the first operand as a tree. */
static inline tree
op_iter_init_tree (ssa_op_iter *ptr, tree stmt, int flags)
{
op_iter_init (ptr, stmt, flags);
return op_iter_next_tree (ptr);
}
/* Get the next iterator maydef value for PTR, returning the maydef values in
USE and DEF. */
static inline void
op_iter_next_maydef (use_operand_p *use, def_operand_p *def, ssa_op_iter *ptr)
{
if (ptr->v_mayu_i < ptr->num_v_mayu)
{
*def = V_MAY_DEF_RESULT_PTR (ptr->ops->v_may_def_ops, ptr->v_mayu_i);
*use = V_MAY_DEF_OP_PTR (ptr->ops->v_may_def_ops, (ptr->v_mayu_i)++);
return;
}
else
{
*def = NULL_DEF_OPERAND_P;
*use = NULL_USE_OPERAND_P;
}
ptr->done = true;
return;
}
/* Initialize iterator PTR to the operands in STMT. Return the first operands
in USE and DEF. */
static inline void
op_iter_init_maydef (ssa_op_iter *ptr, tree stmt, use_operand_p *use,
def_operand_p *def)
{
op_iter_init (ptr, stmt, SSA_OP_VMAYUSE);
op_iter_next_maydef (use, def, ptr);
}
#endif /* _TREE_FLOW_INLINE_H */ #endif /* _TREE_FLOW_INLINE_H */
gcc/tree-outof-ssa.c
...@@ -1461,8 +1461,9 @@ check_replaceable (temp_expr_table_p tab, tree stmt) ...@@ -1461,8 +1461,9 @@ check_replaceable (temp_expr_table_p tab, tree stmt)
def_optype defs; def_optype defs;
use_optype uses; use_optype uses;
tree var, def; tree var, def;
int num_use_ops, version, i; int num_use_ops, version;
var_map map = tab->map; var_map map = tab->map;
ssa_op_iter iter;
if (TREE_CODE (stmt) != MODIFY_EXPR) if (TREE_CODE (stmt) != MODIFY_EXPR)
return false; return false;
...@@ -1512,9 +1513,8 @@ check_replaceable (temp_expr_table_p tab, tree stmt) ...@@ -1512,9 +1513,8 @@ check_replaceable (temp_expr_table_p tab, tree stmt)
version = SSA_NAME_VERSION (def); version = SSA_NAME_VERSION (def);
/* Add this expression to the dependency list for each use partition. */ /* Add this expression to the dependency list for each use partition. */
for (i = 0; i < num_use_ops; i++) FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_USE)
{ {
var = USE_OP (uses, i);
add_dependance (tab, version, var); add_dependance (tab, version, var);
} }
...@@ -1646,11 +1646,10 @@ find_replaceable_in_bb (temp_expr_table_p tab, basic_block bb) ...@@ -1646,11 +1646,10 @@ find_replaceable_in_bb (temp_expr_table_p tab, basic_block bb)
block_stmt_iterator bsi; block_stmt_iterator bsi;
tree stmt, def; tree stmt, def;
stmt_ann_t ann; stmt_ann_t ann;
int partition, num, i; int partition;
use_optype uses;
def_optype defs;
var_map map = tab->map; var_map map = tab->map;
value_expr_p p; value_expr_p p;
ssa_op_iter iter;
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi)) for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
{ {
...@@ -1658,11 +1657,8 @@ find_replaceable_in_bb (temp_expr_table_p tab, basic_block bb) ...@@ -1658,11 +1657,8 @@ find_replaceable_in_bb (temp_expr_table_p tab, basic_block bb)
ann = stmt_ann (stmt); ann = stmt_ann (stmt);
/* Determine if this stmt finishes an existing expression. */ /* Determine if this stmt finishes an existing expression. */
uses = USE_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_USE)
num = NUM_USES (uses);
for (i = 0; i < num; i++)
{ {
def = USE_OP (uses, i);
if (tab->version_info[SSA_NAME_VERSION (def)]) if (tab->version_info[SSA_NAME_VERSION (def)])
{ {
/* Mark expression as replaceable unless stmt is volatile. */ /* Mark expression as replaceable unless stmt is volatile. */
...@@ -1674,11 +1670,8 @@ find_replaceable_in_bb (temp_expr_table_p tab, basic_block bb) ...@@ -1674,11 +1670,8 @@ find_replaceable_in_bb (temp_expr_table_p tab, basic_block bb)
} }
/* Next, see if this stmt kills off an active expression. */ /* Next, see if this stmt kills off an active expression. */
defs = DEF_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_DEF)
num = NUM_DEFS (defs);
for (i = 0; i < num; i++)
{ {
def = DEF_OP (defs, i);
partition = var_to_partition (map, def); partition = var_to_partition (map, def);
if (partition != NO_PARTITION && tab->partition_dep_list[partition]) if (partition != NO_PARTITION && tab->partition_dep_list[partition])
kill_expr (tab, partition, true); kill_expr (tab, partition, true);
...@@ -1880,13 +1873,15 @@ rewrite_trees (var_map map, tree *values) ...@@ -1880,13 +1873,15 @@ rewrite_trees (var_map map, tree *values)
{ {
for (si = bsi_start (bb); !bsi_end_p (si); ) for (si = bsi_start (bb); !bsi_end_p (si); )
{ {
size_t i, num_uses, num_defs; size_t num_uses, num_defs;
use_optype uses; use_optype uses;
def_optype defs; def_optype defs;
tree stmt = bsi_stmt (si); tree stmt = bsi_stmt (si);
use_operand_p use_p; use_operand_p use_p;
def_operand_p def_p;
int remove = 0, is_copy = 0; int remove = 0, is_copy = 0;
stmt_ann_t ann; stmt_ann_t ann;
ssa_op_iter iter;
get_stmt_operands (stmt); get_stmt_operands (stmt);
ann = stmt_ann (stmt); ann = stmt_ann (stmt);
...@@ -1898,10 +1893,8 @@ rewrite_trees (var_map map, tree *values) ...@@ -1898,10 +1893,8 @@ rewrite_trees (var_map map, tree *values)
uses = USE_OPS (ann); uses = USE_OPS (ann);
num_uses = NUM_USES (uses); num_uses = NUM_USES (uses);
FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
for (i = 0; i < num_uses; i++)
{ {
use_p = USE_OP_PTR (uses, i);
if (replace_use_variable (map, use_p, values)) if (replace_use_variable (map, use_p, values))
changed = true; changed = true;
} }
...@@ -1921,10 +1914,8 @@ rewrite_trees (var_map map, tree *values) ...@@ -1921,10 +1914,8 @@ rewrite_trees (var_map map, tree *values)
} }
if (!remove) if (!remove)
{ {
for (i = 0; i < num_defs; i++) FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, iter, SSA_OP_DEF)
{ {
def_operand_p def_p = DEF_OP_PTR (defs, i);
if (replace_def_variable (map, def_p, NULL)) if (replace_def_variable (map, def_p, NULL))
changed = true; changed = true;
......
gcc/tree-pretty-print.c
...@@ -2036,38 +2036,35 @@ newline_and_indent (pretty_printer *buffer, int spc) ...@@ -2036,38 +2036,35 @@ newline_and_indent (pretty_printer *buffer, int spc)
static void static void
dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags) dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
{ {
size_t i; tree use, def;
stmt_ann_t ann = stmt_ann (stmt); use_operand_p use_p;
v_may_def_optype v_may_defs = V_MAY_DEF_OPS (ann); def_operand_p def_p;
v_must_def_optype v_must_defs = V_MUST_DEF_OPS (ann); ssa_op_iter iter;
vuse_optype vuses = VUSE_OPS (ann);
for (i = 0; i < NUM_V_MAY_DEFS (v_may_defs); i++) FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, stmt, iter)
{ {
pp_string (buffer, "# "); pp_string (buffer, "# ");
dump_generic_node (buffer, V_MAY_DEF_RESULT (v_may_defs, i), dump_generic_node (buffer, DEF_FROM_PTR (def_p),
spc + 2, flags, false); spc + 2, flags, false);
pp_string (buffer, " = V_MAY_DEF <"); pp_string (buffer, " = V_MAY_DEF <");
dump_generic_node (buffer, V_MAY_DEF_OP (v_may_defs, i), dump_generic_node (buffer, USE_FROM_PTR (use_p),
spc + 2, flags, false); spc + 2, flags, false);
pp_string (buffer, ">;"); pp_string (buffer, ">;");
newline_and_indent (buffer, spc); newline_and_indent (buffer, spc);
} }
for (i = 0; i < NUM_V_MUST_DEFS (v_must_defs); i++) FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_VMUSTDEF)
{ {
tree v_must_def = V_MUST_DEF_OP (v_must_defs, i);
pp_string (buffer, "# V_MUST_DEF <"); pp_string (buffer, "# V_MUST_DEF <");
dump_generic_node (buffer, v_must_def, spc + 2, flags, false); dump_generic_node (buffer, def, spc + 2, flags, false);
pp_string (buffer, ">;"); pp_string (buffer, ">;");
newline_and_indent (buffer, spc); newline_and_indent (buffer, spc);
} }
for (i = 0; i < NUM_VUSES (vuses); i++) FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_VUSE)
{ {
tree vuse = VUSE_OP (vuses, i);
pp_string (buffer, "# VUSE <"); pp_string (buffer, "# VUSE <");
dump_generic_node (buffer, vuse, spc + 2, flags, false); dump_generic_node (buffer, use, spc + 2, flags, false);
pp_string (buffer, ">;"); pp_string (buffer, ">;");
newline_and_indent (buffer, spc); newline_and_indent (buffer, spc);
} }
......
gcc/tree-sra.c
...@@ -1397,27 +1397,13 @@ decide_instantiations (void) ...@@ -1397,27 +1397,13 @@ decide_instantiations (void)
static void static void
mark_all_v_defs (tree stmt) mark_all_v_defs (tree stmt)
{ {
v_may_def_optype v_may_defs; tree sym;
v_must_def_optype v_must_defs; ssa_op_iter iter;
size_t i, n;
get_stmt_operands (stmt); get_stmt_operands (stmt);
v_may_defs = V_MAY_DEF_OPS (stmt_ann (stmt)); FOR_EACH_SSA_TREE_OPERAND (sym, stmt, iter, SSA_OP_VIRTUAL_DEFS)
n = NUM_V_MAY_DEFS (v_may_defs);
for (i = 0; i < n; i++)
{ {
tree sym = V_MAY_DEF_RESULT (v_may_defs, i);
if (TREE_CODE (sym) == SSA_NAME)
sym = SSA_NAME_VAR (sym);
bitmap_set_bit (vars_to_rename, var_ann (sym)->uid);
}
v_must_defs = V_MUST_DEF_OPS (stmt_ann (stmt));
n = NUM_V_MUST_DEFS (v_must_defs);
for (i = 0; i < n; i++)
{
tree sym = V_MUST_DEF_OP (v_must_defs, i);
if (TREE_CODE (sym) == SSA_NAME) if (TREE_CODE (sym) == SSA_NAME)
sym = SSA_NAME_VAR (sym); sym = SSA_NAME_VAR (sym);
bitmap_set_bit (vars_to_rename, var_ann (sym)->uid); bitmap_set_bit (vars_to_rename, var_ann (sym)->uid);
......
gcc/tree-ssa-alias.c
...@@ -576,6 +576,8 @@ compute_points_to_and_addr_escape (struct alias_info *ai) ...@@ -576,6 +576,8 @@ compute_points_to_and_addr_escape (struct alias_info *ai)
{ {
basic_block bb; basic_block bb;
size_t i; size_t i;
tree op;
ssa_op_iter iter;
timevar_push (TV_TREE_PTA); timevar_push (TV_TREE_PTA);
...@@ -586,11 +588,6 @@ compute_points_to_and_addr_escape (struct alias_info *ai) ...@@ -586,11 +588,6 @@ compute_points_to_and_addr_escape (struct alias_info *ai)
for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si)) for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))
{ {
use_optype uses;
def_optype defs;
v_may_def_optype v_may_defs;
v_must_def_optype v_must_defs;
stmt_ann_t ann;
bitmap addr_taken; bitmap addr_taken;
tree stmt = bsi_stmt (si); tree stmt = bsi_stmt (si);
bool stmt_escapes_p = is_escape_site (stmt, &ai->num_calls_found); bool stmt_escapes_p = is_escape_site (stmt, &ai->num_calls_found);
...@@ -629,11 +626,8 @@ compute_points_to_and_addr_escape (struct alias_info *ai) ...@@ -629,11 +626,8 @@ compute_points_to_and_addr_escape (struct alias_info *ai)
mark_call_clobbered (var); mark_call_clobbered (var);
}); });
ann = stmt_ann (stmt); FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
uses = USE_OPS (ann);
for (i = 0; i < NUM_USES (uses); i++)
{ {
tree op = USE_OP (uses, i);
var_ann_t v_ann = var_ann (SSA_NAME_VAR (op)); var_ann_t v_ann = var_ann (SSA_NAME_VAR (op));
struct ptr_info_def *pi; struct ptr_info_def *pi;
bool is_store; bool is_store;
...@@ -698,10 +692,8 @@ compute_points_to_and_addr_escape (struct alias_info *ai) ...@@ -698,10 +692,8 @@ compute_points_to_and_addr_escape (struct alias_info *ai)
/* Update reference counter for definitions to any /* Update reference counter for definitions to any
potentially aliased variable. This is used in the alias potentially aliased variable. This is used in the alias
grouping heuristics. */ grouping heuristics. */
defs = DEF_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_DEF)
for (i = 0; i < NUM_DEFS (defs); i++)
{ {
tree op = DEF_OP (defs, i);
tree var = SSA_NAME_VAR (op); tree var = SSA_NAME_VAR (op);
var_ann_t ann = var_ann (var); var_ann_t ann = var_ann (var);
bitmap_set_bit (ai->written_vars, ann->uid); bitmap_set_bit (ai->written_vars, ann->uid);
...@@ -710,25 +702,13 @@ compute_points_to_and_addr_escape (struct alias_info *ai) ...@@ -710,25 +702,13 @@ compute_points_to_and_addr_escape (struct alias_info *ai)
} }
/* Mark variables in V_MAY_DEF operands as being written to. */ /* Mark variables in V_MAY_DEF operands as being written to. */
v_may_defs = V_MAY_DEF_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_VIRTUAL_DEFS)
for (i = 0; i < NUM_V_MAY_DEFS (v_may_defs); i++)
{ {
tree op = V_MAY_DEF_OP (v_may_defs, i);
tree var = SSA_NAME_VAR (op); tree var = SSA_NAME_VAR (op);
var_ann_t ann = var_ann (var); var_ann_t ann = var_ann (var);
bitmap_set_bit (ai->written_vars, ann->uid); bitmap_set_bit (ai->written_vars, ann->uid);
} }
/* Mark variables in V_MUST_DEF operands as being written to. */
v_must_defs = V_MUST_DEF_OPS (ann);
for (i = 0; i < NUM_V_MUST_DEFS (v_must_defs); i++)
{
tree op = V_MUST_DEF_OP (v_must_defs, i);
tree var = SSA_NAME_VAR (op);
var_ann_t ann = var_ann (var);
bitmap_set_bit (ai->written_vars, ann->uid);
}
/* After promoting variables and computing aliasing we will /* After promoting variables and computing aliasing we will
need to re-scan most statements. FIXME: Try to minimize the need to re-scan most statements. FIXME: Try to minimize the
number of statements re-scanned. It's not really necessary to number of statements re-scanned. It's not really necessary to
...@@ -2391,6 +2371,7 @@ dump_points_to_info (FILE *file) ...@@ -2391,6 +2371,7 @@ dump_points_to_info (FILE *file)
basic_block bb; basic_block bb;
block_stmt_iterator si; block_stmt_iterator si;
size_t i; size_t i;
ssa_op_iter iter;
const char *fname = const char *fname =
lang_hooks.decl_printable_name (current_function_decl, 2); lang_hooks.decl_printable_name (current_function_decl, 2);
...@@ -2424,12 +2405,11 @@ dump_points_to_info (FILE *file) ...@@ -2424,12 +2405,11 @@ dump_points_to_info (FILE *file)
for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si)) for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))
{ {
stmt_ann_t ann = stmt_ann (bsi_stmt (si)); tree stmt = bsi_stmt (si);
def_optype defs = DEF_OPS (ann); tree def;
if (defs) FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_DEF)
for (i = 0; i < NUM_DEFS (defs); i++) if (POINTER_TYPE_P (TREE_TYPE (def)))
if (POINTER_TYPE_P (TREE_TYPE (DEF_OP (defs, i)))) dump_points_to_info_for (file, def);
dump_points_to_info_for (file, DEF_OP (defs, i));
} }
} }
......
gcc/tree-ssa-ccp.c
...@@ -644,11 +644,11 @@ cp_lattice_meet (value val1, value val2) ...@@ -644,11 +644,11 @@ cp_lattice_meet (value val1, value val2)
static void static void
visit_stmt (tree stmt) visit_stmt (tree stmt)
{ {
size_t i;
stmt_ann_t ann; stmt_ann_t ann;
def_optype defs;
v_may_def_optype v_may_defs; v_may_def_optype v_may_defs;
v_must_def_optype v_must_defs; v_must_def_optype v_must_defs;
tree def;
ssa_op_iter iter;
/* If the statement has already been deemed to be VARYING, don't simulate /* If the statement has already been deemed to be VARYING, don't simulate
it again. */ it again. */
...@@ -684,12 +684,11 @@ visit_stmt (tree stmt) ...@@ -684,12 +684,11 @@ visit_stmt (tree stmt)
/* Definitions made by statements other than assignments to SSA_NAMEs /* Definitions made by statements other than assignments to SSA_NAMEs
represent unknown modifications to their outputs. Mark them VARYING. */ represent unknown modifications to their outputs. Mark them VARYING. */
else if (NUM_DEFS (defs = DEF_OPS (ann)) != 0) else if (NUM_DEFS (DEF_OPS (ann)) != 0)
{ {
DONT_SIMULATE_AGAIN (stmt) = 1; DONT_SIMULATE_AGAIN (stmt) = 1;
for (i = 0; i < NUM_DEFS (defs); i++) FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_DEF)
{ {
tree def = DEF_OP (defs, i);
def_to_varying (def); def_to_varying (def);
} }
} }
...@@ -712,9 +711,8 @@ visit_stmt (tree stmt) ...@@ -712,9 +711,8 @@ visit_stmt (tree stmt)
} }
/* Mark all V_MAY_DEF operands VARYING. */ /* Mark all V_MAY_DEF operands VARYING. */
v_may_defs = V_MAY_DEF_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_VMAYDEF)
for (i = 0; i < NUM_V_MAY_DEFS (v_may_defs); i++) def_to_varying (def);
def_to_varying (V_MAY_DEF_RESULT (v_may_defs, i));
} }
...@@ -1187,6 +1185,8 @@ initialize (void) ...@@ -1187,6 +1185,8 @@ initialize (void)
edge e; edge e;
basic_block bb; basic_block bb;
sbitmap virtual_var; sbitmap virtual_var;
tree def;
ssa_op_iter iter;
/* Worklists of SSA edges. */ /* Worklists of SSA edges. */
VARRAY_TREE_INIT (ssa_edges, 20, "ssa_edges"); VARRAY_TREE_INIT (ssa_edges, 20, "ssa_edges");
...@@ -1211,11 +1211,6 @@ initialize (void) ...@@ -1211,11 +1211,6 @@ initialize (void)
{ {
block_stmt_iterator i; block_stmt_iterator i;
tree stmt; tree stmt;
stmt_ann_t ann;
def_optype defs;
v_may_def_optype v_may_defs;
v_must_def_optype v_must_defs;
size_t x;
int vary; int vary;
/* Get the default value for each definition. */ /* Get the default value for each definition. */
...@@ -1224,33 +1219,22 @@ initialize (void) ...@@ -1224,33 +1219,22 @@ initialize (void)
vary = 0; vary = 0;
stmt = bsi_stmt (i); stmt = bsi_stmt (i);
get_stmt_operands (stmt); get_stmt_operands (stmt);
ann = stmt_ann (stmt);
defs = DEF_OPS (ann); /* Get the default value for each DEF and V_MUST_DEF. */
for (x = 0; x < NUM_DEFS (defs); x++) FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter,
(SSA_OP_DEF | SSA_OP_VMUSTDEF))
{ {
tree def = DEF_OP (defs, x);
if (get_value (def)->lattice_val == VARYING) if (get_value (def)->lattice_val == VARYING)
vary = 1; vary = 1;
} }
/* Get the default value for each V_MUST_DEF. */
v_must_defs = V_MUST_DEF_OPS (ann);
for (x = 0; x < NUM_V_MUST_DEFS (v_must_defs); x++)
{
tree v_must_def = V_MUST_DEF_OP (v_must_defs, x);
if (get_value (v_must_def)->lattice_val == VARYING)
vary = 1;
}
DONT_SIMULATE_AGAIN (stmt) = vary; DONT_SIMULATE_AGAIN (stmt) = vary;
/* Mark all V_MAY_DEF operands VARYING. */ /* Mark all V_MAY_DEF operands VARYING. */
v_may_defs = V_MAY_DEF_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_VMAYDEF)
for (x = 0; x < NUM_V_MAY_DEFS (v_may_defs); x++)
{ {
tree res = V_MAY_DEF_RESULT (v_may_defs, x); get_value (def)->lattice_val = VARYING;
get_value (res)->lattice_val = VARYING; SET_BIT (virtual_var, SSA_NAME_VERSION (def));
SET_BIT (virtual_var, SSA_NAME_VERSION (res));
} }
} }
...@@ -1494,18 +1478,16 @@ static bool ...@@ -1494,18 +1478,16 @@ static bool
replace_uses_in (tree stmt, bool *replaced_addresses_p) replace_uses_in (tree stmt, bool *replaced_addresses_p)
{ {
bool replaced = false; bool replaced = false;
use_optype uses; use_operand_p use;
size_t i; ssa_op_iter iter;
if (replaced_addresses_p) if (replaced_addresses_p)
*replaced_addresses_p = false; *replaced_addresses_p = false;
get_stmt_operands (stmt); get_stmt_operands (stmt);
uses = STMT_USE_OPS (stmt); FOR_EACH_SSA_USE_OPERAND (use, stmt, iter, SSA_OP_USE)
for (i = 0; i < NUM_USES (uses); i++)
{ {
use_operand_p use = USE_OP_PTR (uses, i);
value *val = get_value (USE_FROM_PTR (use)); value *val = get_value (USE_FROM_PTR (use));
if (val->lattice_val == CONSTANT) if (val->lattice_val == CONSTANT)
...@@ -1575,11 +1557,11 @@ replace_vuse_in (tree stmt, bool *replaced_addresses_p) ...@@ -1575,11 +1557,11 @@ replace_vuse_in (tree stmt, bool *replaced_addresses_p)
static latticevalue static latticevalue
likely_value (tree stmt) likely_value (tree stmt)
{ {
use_optype uses;
vuse_optype vuses; vuse_optype vuses;
size_t i;
int found_constant = 0; int found_constant = 0;
stmt_ann_t ann; stmt_ann_t ann;
tree use;
ssa_op_iter iter;
/* If the statement makes aliased loads or has volatile operands, it /* If the statement makes aliased loads or has volatile operands, it
won't fold to a constant value. */ won't fold to a constant value. */
...@@ -1594,10 +1576,8 @@ likely_value (tree stmt) ...@@ -1594,10 +1576,8 @@ likely_value (tree stmt)
get_stmt_operands (stmt); get_stmt_operands (stmt);
uses = USE_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE)
for (i = 0; i < NUM_USES (uses); i++)
{ {
tree use = USE_OP (uses, i);
value *val = get_value (use); value *val = get_value (use);
if (val->lattice_val == UNDEFINED) if (val->lattice_val == UNDEFINED)
...@@ -1627,7 +1607,7 @@ likely_value (tree stmt) ...@@ -1627,7 +1607,7 @@ likely_value (tree stmt)
found_constant = 1; found_constant = 1;
} }
return ((found_constant || (!uses && !vuses)) ? CONSTANT : VARYING); return ((found_constant || (!USE_OPS (ann) && !vuses)) ? CONSTANT : VARYING);
} }
/* A subroutine of fold_stmt_r. Attempts to fold *(A+O) to A[X]. /* A subroutine of fold_stmt_r. Attempts to fold *(A+O) to A[X].
...@@ -2266,6 +2246,8 @@ set_rhs (tree *stmt_p, tree expr) ...@@ -2266,6 +2246,8 @@ set_rhs (tree *stmt_p, tree expr)
tree stmt = *stmt_p, op; tree stmt = *stmt_p, op;
enum tree_code code = TREE_CODE (expr); enum tree_code code = TREE_CODE (expr);
stmt_ann_t ann; stmt_ann_t ann;
tree var;
ssa_op_iter iter;
/* Verify the constant folded result is valid gimple. */ /* Verify the constant folded result is valid gimple. */
if (TREE_CODE_CLASS (code) == '2') if (TREE_CODE_CLASS (code) == '2')
...@@ -2321,33 +2303,10 @@ set_rhs (tree *stmt_p, tree expr) ...@@ -2321,33 +2303,10 @@ set_rhs (tree *stmt_p, tree expr)
if (TREE_SIDE_EFFECTS (expr)) if (TREE_SIDE_EFFECTS (expr))
{ {
def_optype defs;
v_may_def_optype v_may_defs;
v_must_def_optype v_must_defs;
size_t i;
/* Fix all the SSA_NAMEs created by *STMT_P to point to its new /* Fix all the SSA_NAMEs created by *STMT_P to point to its new
replacement. */ replacement. */
defs = DEF_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_ALL_DEFS)
for (i = 0; i < NUM_DEFS (defs); i++)
{
tree var = DEF_OP (defs, i);
if (TREE_CODE (var) == SSA_NAME)
SSA_NAME_DEF_STMT (var) = *stmt_p;
}
v_may_defs = V_MAY_DEF_OPS (ann);
for (i = 0; i < NUM_V_MAY_DEFS (v_may_defs); i++)
{
tree var = V_MAY_DEF_RESULT (v_may_defs, i);
if (TREE_CODE (var) == SSA_NAME)
SSA_NAME_DEF_STMT (var) = *stmt_p;
}
v_must_defs = V_MUST_DEF_OPS (ann);
for (i = 0; i < NUM_V_MUST_DEFS (v_must_defs); i++)
{ {
tree var = V_MUST_DEF_OP (v_must_defs, i);
if (TREE_CODE (var) == SSA_NAME) if (TREE_CODE (var) == SSA_NAME)
SSA_NAME_DEF_STMT (var) = *stmt_p; SSA_NAME_DEF_STMT (var) = *stmt_p;
} }
......
gcc/tree-ssa-dce.c
...@@ -276,12 +276,11 @@ mark_operand_necessary (tree op) ...@@ -276,12 +276,11 @@ mark_operand_necessary (tree op)
static void static void
mark_stmt_if_obviously_necessary (tree stmt, bool aggressive) mark_stmt_if_obviously_necessary (tree stmt, bool aggressive)
{ {
def_optype defs;
v_may_def_optype v_may_defs; v_may_def_optype v_may_defs;
v_must_def_optype v_must_defs; v_must_def_optype v_must_defs;
stmt_ann_t ann; stmt_ann_t ann;
size_t i; tree op, def;
tree op; ssa_op_iter iter;
/* Statements that are implicitly live. Most function calls, asm and return /* Statements that are implicitly live. Most function calls, asm and return
statements are required. Labels and BIND_EXPR nodes are kept because statements are required. Labels and BIND_EXPR nodes are kept because
...@@ -370,10 +369,8 @@ mark_stmt_if_obviously_necessary (tree stmt, bool aggressive) ...@@ -370,10 +369,8 @@ mark_stmt_if_obviously_necessary (tree stmt, bool aggressive)
get_stmt_operands (stmt); get_stmt_operands (stmt);
defs = DEF_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_DEF)
for (i = 0; i < NUM_DEFS (defs); i++)
{ {
tree def = DEF_OP (defs, i);
if (is_global_var (SSA_NAME_VAR (def))) if (is_global_var (SSA_NAME_VAR (def)))
{ {
mark_stmt_necessary (stmt, true); mark_stmt_necessary (stmt, true);
...@@ -627,30 +624,18 @@ propagate_necessity (struct edge_list *el) ...@@ -627,30 +624,18 @@ propagate_necessity (struct edge_list *el)
/* Propagate through the operands. Examine all the USE, VUSE and /* Propagate through the operands. Examine all the USE, VUSE and
V_MAY_DEF operands in this statement. Mark all the statements V_MAY_DEF operands in this statement. Mark all the statements
which feed this statement's uses as necessary. */ which feed this statement's uses as necessary. */
vuse_optype vuses; ssa_op_iter iter;
v_may_def_optype v_may_defs; tree use;
use_optype uses;
stmt_ann_t ann;
size_t k;
get_stmt_operands (i); get_stmt_operands (i);
ann = stmt_ann (i);
uses = USE_OPS (ann);
for (k = 0; k < NUM_USES (uses); k++)
mark_operand_necessary (USE_OP (uses, k));
vuses = VUSE_OPS (ann);
for (k = 0; k < NUM_VUSES (vuses); k++)
mark_operand_necessary (VUSE_OP (vuses, k));
/* The operands of V_MAY_DEF expressions are also needed as they /* The operands of V_MAY_DEF expressions are also needed as they
represent potential definitions that may reach this represent potential definitions that may reach this
statement (V_MAY_DEF operands allow us to follow def-def statement (V_MAY_DEF operands allow us to follow def-def
links). */ links). */
v_may_defs = V_MAY_DEF_OPS (ann);
for (k = 0; k < NUM_V_MAY_DEFS (v_may_defs); k++) FOR_EACH_SSA_TREE_OPERAND (use, i, iter, SSA_OP_ALL_USES)
mark_operand_necessary (V_MAY_DEF_OP (v_may_defs, k)); mark_operand_necessary (use);
} }
} }
} }
......
gcc/tree-ssa-dom.c
...@@ -253,7 +253,7 @@ static void restore_vars_to_original_value (varray_type locals, ...@@ -253,7 +253,7 @@ static void restore_vars_to_original_value (varray_type locals,
varray_type table); varray_type table);
static void restore_currdefs_to_original_value (varray_type locals, static void restore_currdefs_to_original_value (varray_type locals,
unsigned limit); unsigned limit);
static void register_definitions_for_stmt (stmt_ann_t, varray_type *); static void register_definitions_for_stmt (tree, varray_type *);
static edge single_incoming_edge_ignoring_loop_edges (basic_block); static edge single_incoming_edge_ignoring_loop_edges (basic_block);
/* Local version of fold that doesn't introduce cruft. */ /* Local version of fold that doesn't introduce cruft. */
...@@ -2698,41 +2698,16 @@ static bool ...@@ -2698,41 +2698,16 @@ static bool
cprop_into_stmt (tree stmt, varray_type const_and_copies) cprop_into_stmt (tree stmt, varray_type const_and_copies)
{ {
bool may_have_exposed_new_symbols = false; bool may_have_exposed_new_symbols = false;
stmt_ann_t ann = stmt_ann (stmt); use_operand_p op_p;
size_t i, num_uses, num_vuses, num_v_may_defs; ssa_op_iter iter;
vuse_optype vuses;
v_may_def_optype v_may_defs;
use_optype uses;
uses = USE_OPS (ann);
num_uses = NUM_USES (uses);
for (i = 0; i < num_uses; i++)
{
use_operand_p op_p = USE_OP_PTR (uses, i);
if (TREE_CODE (USE_FROM_PTR (op_p)) == SSA_NAME)
may_have_exposed_new_symbols
|= cprop_operand (stmt, op_p, const_and_copies);
}
vuses = VUSE_OPS (ann); FOR_EACH_SSA_USE_OPERAND (op_p, stmt, iter, SSA_OP_ALL_USES)
num_vuses = NUM_VUSES (vuses);
for (i = 0; i < num_vuses; i++)
{ {
use_operand_p op_p = VUSE_OP_PTR (vuses, i);
if (TREE_CODE (USE_FROM_PTR (op_p)) == SSA_NAME) if (TREE_CODE (USE_FROM_PTR (op_p)) == SSA_NAME)
may_have_exposed_new_symbols may_have_exposed_new_symbols
|= cprop_operand (stmt, op_p, const_and_copies); |= cprop_operand (stmt, op_p, const_and_copies);
} }
v_may_defs = V_MAY_DEF_OPS (ann);
num_v_may_defs = NUM_V_MAY_DEFS (v_may_defs);
for (i = 0; i < num_v_may_defs; i++)
{
use_operand_p op_p = V_MAY_DEF_OP_PTR (v_may_defs, i);
if (TREE_CODE (USE_FROM_PTR (op_p)) == SSA_NAME)
may_have_exposed_new_symbols
|= cprop_operand (stmt, op_p, const_and_copies);
}
return may_have_exposed_new_symbols; return may_have_exposed_new_symbols;
} }
...@@ -2830,7 +2805,7 @@ optimize_stmt (struct dom_walk_data *walk_data, basic_block bb, ...@@ -2830,7 +2805,7 @@ optimize_stmt (struct dom_walk_data *walk_data, basic_block bb,
may_optimize_p, may_optimize_p,
ann); ann);
register_definitions_for_stmt (ann, &bd->block_defs); register_definitions_for_stmt (stmt, &bd->block_defs);
/* If STMT is a COND_EXPR and it was modified, then we may know /* If STMT is a COND_EXPR and it was modified, then we may know
where it goes. If that is the case, then mark the CFG as altered. where it goes. If that is the case, then mark the CFG as altered.
...@@ -3373,39 +3348,17 @@ avail_expr_eq (const void *p1, const void *p2) ...@@ -3373,39 +3348,17 @@ avail_expr_eq (const void *p1, const void *p2)
and CURRDEFS. */ and CURRDEFS. */
static void static void
register_definitions_for_stmt (stmt_ann_t ann, varray_type *block_defs_p) register_definitions_for_stmt (tree stmt, varray_type *block_defs_p)
{ {
def_optype defs; tree def;
v_may_def_optype v_may_defs; ssa_op_iter iter;
v_must_def_optype v_must_defs;
unsigned int i;
defs = DEF_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS)
for (i = 0; i < NUM_DEFS (defs); i++)
{ {
tree def = DEF_OP (defs, i);
/* FIXME: We shouldn't be registering new defs if the variable /* FIXME: We shouldn't be registering new defs if the variable
doesn't need to be renamed. */ doesn't need to be renamed. */
register_new_def (def, block_defs_p); register_new_def (def, block_defs_p);
} }
/* Register new virtual definitions made by the statement. */
v_may_defs = V_MAY_DEF_OPS (ann);
for (i = 0; i < NUM_V_MAY_DEFS (v_may_defs); i++)
{
/* FIXME: We shouldn't be registering new defs if the variable
doesn't need to be renamed. */
register_new_def (V_MAY_DEF_RESULT (v_may_defs, i), block_defs_p);
}
/* Register new virtual mustdefs made by the statement. */
v_must_defs = V_MUST_DEF_OPS (ann);
for (i = 0; i < NUM_V_MUST_DEFS (v_must_defs); i++)
{
/* FIXME: We shouldn't be registering new defs if the variable
doesn't need to be renamed. */
register_new_def (V_MUST_DEF_OP (v_must_defs, i), block_defs_p);
}
} }
gcc/tree-ssa-live.c
...@@ -325,16 +325,11 @@ create_ssa_var_map (int flags) ...@@ -325,16 +325,11 @@ create_ssa_var_map (int flags)
tree dest, use; tree dest, use;
tree stmt; tree stmt;
stmt_ann_t ann; stmt_ann_t ann;
use_optype uses;
def_optype defs;
unsigned x;
var_map map; var_map map;
ssa_op_iter iter;
#ifdef ENABLE_CHECKING #ifdef ENABLE_CHECKING
sbitmap used_in_real_ops; sbitmap used_in_real_ops;
sbitmap used_in_virtual_ops; sbitmap used_in_virtual_ops;
vuse_optype vuses;
v_may_def_optype v_may_defs;
v_must_def_optype v_must_defs;
#endif #endif
map = init_var_map (num_ssa_names + 1); map = init_var_map (num_ssa_names + 1);
...@@ -378,10 +373,8 @@ create_ssa_var_map (int flags) ...@@ -378,10 +373,8 @@ create_ssa_var_map (int flags)
ann = stmt_ann (stmt); ann = stmt_ann (stmt);
/* Register USE and DEF operands in each statement. */ /* Register USE and DEF operands in each statement. */
uses = USE_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (use , stmt, iter, SSA_OP_USE)
for (x = 0; x < NUM_USES (uses); x++)
{ {
use = USE_OP (uses, x);
register_ssa_partition (map, use, true); register_ssa_partition (map, use, true);
#ifdef ENABLE_CHECKING #ifdef ENABLE_CHECKING
...@@ -389,10 +382,8 @@ create_ssa_var_map (int flags) ...@@ -389,10 +382,8 @@ create_ssa_var_map (int flags)
#endif #endif
} }
defs = DEF_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (dest, stmt, iter, SSA_OP_DEF)
for (x = 0; x < NUM_DEFS (defs); x++)
{ {
dest = DEF_OP (defs, x);
register_ssa_partition (map, dest, false); register_ssa_partition (map, dest, false);
#ifdef ENABLE_CHECKING #ifdef ENABLE_CHECKING
...@@ -402,26 +393,12 @@ create_ssa_var_map (int flags) ...@@ -402,26 +393,12 @@ create_ssa_var_map (int flags)
#ifdef ENABLE_CHECKING #ifdef ENABLE_CHECKING
/* Validate that virtual ops don't get used in funny ways. */ /* Validate that virtual ops don't get used in funny ways. */
vuses = VUSE_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter,
for (x = 0; x < NUM_VUSES (vuses); x++) SSA_OP_VIRTUAL_USES | SSA_OP_VMUSTDEF)
{ {
tree var = VUSE_OP (vuses, x); SET_BIT (used_in_virtual_ops, var_ann (SSA_NAME_VAR (use))->uid);
SET_BIT (used_in_virtual_ops, var_ann (SSA_NAME_VAR (var))->uid);
} }
v_may_defs = V_MAY_DEF_OPS (ann);
for (x = 0; x < NUM_V_MAY_DEFS (v_may_defs); x++)
{
tree var = V_MAY_DEF_OP (v_may_defs, x);
SET_BIT (used_in_virtual_ops, var_ann (SSA_NAME_VAR (var))->uid);
}
v_must_defs = V_MUST_DEF_OPS (ann);
for (x = 0; x < NUM_V_MUST_DEFS (v_must_defs); x++)
{
tree var = V_MUST_DEF_OP (v_must_defs, x);
SET_BIT (used_in_virtual_ops, var_ann (SSA_NAME_VAR (var))->uid);
}
#endif /* ENABLE_CHECKING */ #endif /* ENABLE_CHECKING */
mark_all_vars_used (bsi_stmt_ptr (bsi)); mark_all_vars_used (bsi_stmt_ptr (bsi));
...@@ -579,7 +556,7 @@ tree_live_info_p ...@@ -579,7 +556,7 @@ tree_live_info_p
calculate_live_on_entry (var_map map) calculate_live_on_entry (var_map map)
{ {
tree_live_info_p live; tree_live_info_p live;
int num, i; int i;
basic_block bb; basic_block bb;
bitmap saw_def; bitmap saw_def;
tree phi, var, stmt; tree phi, var, stmt;
...@@ -587,9 +564,12 @@ calculate_live_on_entry (var_map map) ...@@ -587,9 +564,12 @@ calculate_live_on_entry (var_map map)
edge e; edge e;
varray_type stack; varray_type stack;
block_stmt_iterator bsi; block_stmt_iterator bsi;
use_optype uses;
def_optype defs;
stmt_ann_t ann; stmt_ann_t ann;
ssa_op_iter iter;
#ifdef ENABLE_CHECKING
int num;
#endif
saw_def = BITMAP_XMALLOC (); saw_def = BITMAP_XMALLOC ();
...@@ -636,19 +616,13 @@ calculate_live_on_entry (var_map map) ...@@ -636,19 +616,13 @@ calculate_live_on_entry (var_map map)
get_stmt_operands (stmt); get_stmt_operands (stmt);
ann = stmt_ann (stmt); ann = stmt_ann (stmt);
uses = USE_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
num = NUM_USES (uses);
for (i = 0; i < num; i++)
{ {
op = USE_OP (uses, i);
add_livein_if_notdef (live, saw_def, op, bb); add_livein_if_notdef (live, saw_def, op, bb);
} }
defs = DEF_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_DEF)
num = NUM_DEFS (defs);
for (i = 0; i < num; i++)
{ {
op = DEF_OP (defs, i);
set_if_valid (map, saw_def, op); set_if_valid (map, saw_def, op);
} }
} }
...@@ -1332,12 +1306,11 @@ build_tree_conflict_graph (tree_live_info_p liveinfo, tpa_p tpa, ...@@ -1332,12 +1306,11 @@ build_tree_conflict_graph (tree_live_info_p liveinfo, tpa_p tpa,
conflict_graph graph; conflict_graph graph;
var_map map; var_map map;
bitmap live; bitmap live;
int num, x, y, i; int x, y, i;
basic_block bb; basic_block bb;
varray_type partition_link, tpa_to_clear, tpa_nodes; varray_type partition_link, tpa_to_clear, tpa_nodes;
def_optype defs;
use_optype uses;
unsigned l; unsigned l;
ssa_op_iter iter;
map = live_var_map (liveinfo); map = live_var_map (liveinfo);
graph = conflict_graph_new (num_var_partitions (map)); graph = conflict_graph_new (num_var_partitions (map));
...@@ -1415,20 +1388,13 @@ build_tree_conflict_graph (tree_live_info_p liveinfo, tpa_p tpa, ...@@ -1415,20 +1388,13 @@ build_tree_conflict_graph (tree_live_info_p liveinfo, tpa_p tpa,
if (!is_a_copy) if (!is_a_copy)
{ {
tree var; tree var;
FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_DEF)
defs = DEF_OPS (ann);
num = NUM_DEFS (defs);
for (x = 0; x < num; x++)
{ {
var = DEF_OP (defs, x);
add_conflicts_if_valid (tpa, graph, map, live, var); add_conflicts_if_valid (tpa, graph, map, live, var);
} }
uses = USE_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_USE)
num = NUM_USES (uses);
for (x = 0; x < num; x++)
{ {
var = USE_OP (uses, x);
set_if_valid (map, live, var); set_if_valid (map, live, var);
} }
} }
......
gcc/tree-ssa-loop-im.c
...@@ -406,11 +406,8 @@ determine_max_movement (tree stmt, bool must_preserve_exec) ...@@ -406,11 +406,8 @@ determine_max_movement (tree stmt, bool must_preserve_exec)
struct loop *loop = bb->loop_father; struct loop *loop = bb->loop_father;
struct loop *level; struct loop *level;
struct lim_aux_data *lim_data = LIM_DATA (stmt); struct lim_aux_data *lim_data = LIM_DATA (stmt);
use_optype uses; tree val;
vuse_optype vuses; ssa_op_iter iter;
v_may_def_optype v_may_defs;
stmt_ann_t ann = stmt_ann (stmt);
unsigned i;
if (must_preserve_exec) if (must_preserve_exec)
level = ALWAYS_EXECUTED_IN (bb); level = ALWAYS_EXECUTED_IN (bb);
...@@ -418,19 +415,12 @@ determine_max_movement (tree stmt, bool must_preserve_exec) ...@@ -418,19 +415,12 @@ determine_max_movement (tree stmt, bool must_preserve_exec)
level = superloop_at_depth (loop, 1); level = superloop_at_depth (loop, 1);
lim_data->max_loop = level; lim_data->max_loop = level;
uses = USE_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter, SSA_OP_USE)
for (i = 0; i < NUM_USES (uses); i++) if (!add_dependency (val, lim_data, loop, true))
if (!add_dependency (USE_OP (uses, i), lim_data, loop, true))
return false;
vuses = VUSE_OPS (ann);
for (i = 0; i < NUM_VUSES (vuses); i++)
if (!add_dependency (VUSE_OP (vuses, i), lim_data, loop, false))
return false; return false;
v_may_defs = V_MAY_DEF_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter, SSA_OP_VIRTUAL_USES)
for (i = 0; i < NUM_V_MAY_DEFS (v_may_defs); i++) if (!add_dependency (val, lim_data, loop, false))
if (!add_dependency (V_MAY_DEF_OP (v_may_defs, i), lim_data, loop, false))
return false; return false;
lim_data->cost += stmt_cost (stmt); lim_data->cost += stmt_cost (stmt);
...@@ -926,10 +916,10 @@ single_reachable_address (struct loop *loop, tree stmt, ...@@ -926,10 +916,10 @@ single_reachable_address (struct loop *loop, tree stmt,
unsigned in_queue = 1; unsigned in_queue = 1;
dataflow_t df; dataflow_t df;
unsigned i, n; unsigned i, n;
v_may_def_optype v_may_defs;
vuse_optype vuses;
struct sra_data sra_data; struct sra_data sra_data;
tree call; tree call;
tree val;
ssa_op_iter iter;
sbitmap_zero (seen); sbitmap_zero (seen);
...@@ -970,15 +960,9 @@ single_reachable_address (struct loop *loop, tree stmt, ...@@ -970,15 +960,9 @@ single_reachable_address (struct loop *loop, tree stmt,
/* Traverse also definitions of the VUSES (there may be other /* Traverse also definitions of the VUSES (there may be other
distinct from the one we used to get to this statement). */ distinct from the one we used to get to this statement). */
v_may_defs = STMT_V_MAY_DEF_OPS (stmt); FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter, SSA_OP_VIRTUAL_USES)
for (i = 0; i < NUM_V_MAY_DEFS (v_may_defs); i++) maybe_queue_var (val, loop, seen, queue, &in_queue);
maybe_queue_var (V_MAY_DEF_OP (v_may_defs, i), loop,
seen, queue, &in_queue);
vuses = STMT_VUSE_OPS (stmt);
for (i = 0; i < NUM_VUSES (vuses); i++)
maybe_queue_var (VUSE_OP (vuses, i), loop,
seen, queue, &in_queue);
break; break;
case PHI_NODE: case PHI_NODE:
...@@ -1029,32 +1013,15 @@ fail: ...@@ -1029,32 +1013,15 @@ fail:
static void static void
rewrite_mem_refs (tree tmp_var, struct mem_ref *mem_refs) rewrite_mem_refs (tree tmp_var, struct mem_ref *mem_refs)
{ {
v_may_def_optype v_may_defs;
v_must_def_optype v_must_defs;
vuse_optype vuses;
unsigned i;
tree var; tree var;
ssa_op_iter iter;
for (; mem_refs; mem_refs = mem_refs->next) for (; mem_refs; mem_refs = mem_refs->next)
{ {
v_may_defs = STMT_V_MAY_DEF_OPS (mem_refs->stmt); FOR_EACH_SSA_TREE_OPERAND (var, mem_refs->stmt, iter,
for (i = 0; i < NUM_V_MAY_DEFS (v_may_defs); i++) (SSA_OP_VIRTUAL_DEFS | SSA_OP_VUSE))
{
var = SSA_NAME_VAR (V_MAY_DEF_RESULT (v_may_defs, i));
bitmap_set_bit (vars_to_rename, var_ann (var)->uid);
}
v_must_defs = STMT_V_MUST_DEF_OPS (mem_refs->stmt);
for (i = 0; i < NUM_V_MUST_DEFS (v_must_defs); i++)
{
var = SSA_NAME_VAR (V_MUST_DEF_OP (v_must_defs, i));
bitmap_set_bit (vars_to_rename, var_ann (var)->uid);
}
vuses = STMT_VUSE_OPS (mem_refs->stmt);
for (i = 0; i < NUM_VUSES (vuses); i++)
{ {
var = SSA_NAME_VAR (VUSE_OP (vuses, i)); var = SSA_NAME_VAR (var);
bitmap_set_bit (vars_to_rename, var_ann (var)->uid); bitmap_set_bit (vars_to_rename, var_ann (var)->uid);
} }
......
gcc/tree-ssa-loop-manip.c
...@@ -236,27 +236,14 @@ find_uses_to_rename_use (basic_block bb, tree use, bitmap *use_blocks) ...@@ -236,27 +236,14 @@ find_uses_to_rename_use (basic_block bb, tree use, bitmap *use_blocks)
static void static void
find_uses_to_rename_stmt (tree stmt, bitmap *use_blocks) find_uses_to_rename_stmt (tree stmt, bitmap *use_blocks)
{ {
use_optype uses; ssa_op_iter iter;
vuse_optype vuses; tree var;
v_may_def_optype v_may_defs;
stmt_ann_t ann;
unsigned i;
basic_block bb = bb_for_stmt (stmt); basic_block bb = bb_for_stmt (stmt);
get_stmt_operands (stmt); get_stmt_operands (stmt);
ann = stmt_ann (stmt);
uses = USE_OPS (ann);
for (i = 0; i < NUM_USES (uses); i++)
find_uses_to_rename_use (bb, USE_OP (uses, i), use_blocks);
vuses = VUSE_OPS (ann);
for (i = 0; i < NUM_VUSES (vuses); i++)
find_uses_to_rename_use (bb, VUSE_OP (vuses, i),use_blocks);
v_may_defs = V_MAY_DEF_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_ALL_USES)
for (i = 0; i < NUM_V_MAY_DEFS (v_may_defs); i++) find_uses_to_rename_use (bb, var, use_blocks);
find_uses_to_rename_use (bb, V_MAY_DEF_OP (v_may_defs, i), use_blocks);
} }
/* Marks names that are used outside of the loop they are defined in /* Marks names that are used outside of the loop they are defined in
...@@ -363,26 +350,13 @@ check_loop_closed_ssa_use (basic_block bb, tree use) ...@@ -363,26 +350,13 @@ check_loop_closed_ssa_use (basic_block bb, tree use)
static void static void
check_loop_closed_ssa_stmt (basic_block bb, tree stmt) check_loop_closed_ssa_stmt (basic_block bb, tree stmt)
{ {
use_optype uses; ssa_op_iter iter;
vuse_optype vuses; tree var;
v_may_def_optype v_may_defs;
stmt_ann_t ann;
unsigned i;
get_stmt_operands (stmt); get_stmt_operands (stmt);
ann = stmt_ann (stmt);
uses = USE_OPS (ann);
for (i = 0; i < NUM_USES (uses); i++)
check_loop_closed_ssa_use (bb, USE_OP (uses, i));
vuses = VUSE_OPS (ann);
for (i = 0; i < NUM_VUSES (vuses); i++)
check_loop_closed_ssa_use (bb, VUSE_OP (vuses, i));
v_may_defs = V_MAY_DEF_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_ALL_USES)
for (i = 0; i < NUM_V_MAY_DEFS (v_may_defs); i++) check_loop_closed_ssa_use (bb, var);
check_loop_closed_ssa_use (bb, V_MAY_DEF_OP (v_may_defs, i));
} }
/* Checks that invariants of the loop closed ssa form are preserved. */ /* Checks that invariants of the loop closed ssa form are preserved. */
......
gcc/tree-ssa-operands.c
...@@ -114,11 +114,15 @@ static GTY (()) varray_type build_vuses; ...@@ -114,11 +114,15 @@ static GTY (()) varray_type build_vuses;
/* Array for building all the v_must_def operands. */ /* Array for building all the v_must_def operands. */
static GTY (()) varray_type build_v_must_defs; static GTY (()) varray_type build_v_must_defs;
#ifdef ENABLE_CHECKING #ifdef ENABLE_CHECKING
/* Used to make sure operand construction is working on the proper stmt. */ /* Used to make sure operand construction is working on the proper stmt. */
tree check_build_stmt; tree check_build_stmt;
#endif #endif
def_operand_p NULL_DEF_OPERAND_P = { NULL };
use_operand_p NULL_USE_OPERAND_P = { NULL };
static void note_addressable (tree, stmt_ann_t); static void note_addressable (tree, stmt_ann_t);
static void get_expr_operands (tree, tree *, int); static void get_expr_operands (tree, tree *, int);
static void get_asm_expr_operands (tree); static void get_asm_expr_operands (tree);
......
gcc/tree-ssa-operands.h
...@@ -36,6 +36,8 @@ typedef struct use_operand_ptr GTY(()) ...@@ -36,6 +36,8 @@ typedef struct use_operand_ptr GTY(())
tree * GTY((skip(""))) use; tree * GTY((skip(""))) use;
} use_operand_p; } use_operand_p;
extern def_operand_p NULL_DEF_OPERAND_P;
extern use_operand_p NULL_USE_OPERAND_P;
/* This represents the DEF operands of a stmt. */ /* This represents the DEF operands of a stmt. */
typedef struct def_optype_d GTY(()) typedef struct def_optype_d GTY(())
...@@ -184,4 +186,76 @@ extern void get_stmt_operands (tree); ...@@ -184,4 +186,76 @@ extern void get_stmt_operands (tree);
extern void copy_virtual_operands (tree, tree); extern void copy_virtual_operands (tree, tree);
extern void create_ssa_artficial_load_stmt (stmt_operands_p, tree); extern void create_ssa_artficial_load_stmt (stmt_operands_p, tree);
/* This structure is used in the operand iterator loops. It contains the
items required to determine which operand is retreived next. During
optimization, this structure is scalarized, and any unused fields are
optimized away, resulting in little overhead. */
typedef struct ssa_operand_iterator_d
{
int num_use;
int num_def;
int num_vuse;
int num_v_mayu;
int num_v_mayd;
int num_v_must;
int use_i;
int def_i;
int vuse_i;
int v_mayu_i;
int v_mayd_i;
int v_must_i;
stmt_operands_p ops;
bool done;
} ssa_op_iter;
/* These flags are used to determine which operands are returned during
execution of the loop. */
#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_VMAYUSE 0x08 /* USE portion of V_MAY_DEFS. */
#define SSA_OP_VMAYDEF 0x10 /* DEF portion of V_MAY_DEFS. */
#define SSA_OP_VMUSTDEF 0x20 /* V_MUST_DEF defintions. */
/* These are commonly grouped operand flags. */
#define SSA_OP_VIRTUAL_USES (SSA_OP_VUSE | SSA_OP_VMAYUSE)
#define SSA_OP_VIRTUAL_DEFS (SSA_OP_VMAYDEF | SSA_OP_VMUSTDEF)
#define SSA_OP_ALL_USES (SSA_OP_VIRTUAL_USES | SSA_OP_USE)
#define SSA_OP_ALL_DEFS (SSA_OP_VIRTUAL_DEFS | SSA_OP_DEF)
#define SSA_OP_ALL_OPERANDS (SSA_OP_ALL_USES | SSA_OP_ALL_DEFS)
/* This macro executes a loop over the operands of STMT specified in FLAG,
returning each operand as a 'tree' in the variable TREEVAR. ITER is an
ssa_op_iter structure used to control the loop. */
#define FOR_EACH_SSA_TREE_OPERAND(TREEVAR, STMT, ITER, FLAGS) \
for (TREEVAR = op_iter_init_tree (&(ITER), STMT, FLAGS); \
!op_iter_done (&(ITER)); \
TREEVAR = op_iter_next_tree (&(ITER)))
/* This macro executes a loop over the operands of STMT specified in FLAG,
returning each operand as a 'use_operand_p' in the variable USEVAR.
ITER is an ssa_op_iter structure used to control the loop. */
#define FOR_EACH_SSA_USE_OPERAND(USEVAR, STMT, ITER, FLAGS) \
for (USEVAR = op_iter_init_use (&(ITER), STMT, FLAGS); \
!op_iter_done (&(ITER)); \
USEVAR = op_iter_next_use (&(ITER)))
/* This macro executes a loop over the operands of STMT specified in FLAG,
returning each operand as a 'def_operand_p' in the variable DEFVAR.
ITER is an ssa_op_iter structure used to control the loop. */
#define FOR_EACH_SSA_DEF_OPERAND(DEFVAR, STMT, ITER, FLAGS) \
for (DEFVAR = op_iter_init_def (&(ITER), STMT, FLAGS); \
!op_iter_done (&(ITER)); \
DEFVAR = op_iter_next_def (&(ITER)))
/* This macro executes a loop over the V_MAY_DEF operands of STMT. The def
and use for each V_MAY_DEF is returned in DEFVAR and USEVAR.
ITER is an ssa_op_iter structure used to control the loop. */
#define FOR_EACH_SSA_MAYDEF_OPERAND(DEFVAR, USEVAR, STMT, ITER) \
for (op_iter_init_maydef (&(ITER), STMT, &(USEVAR), &(DEFVAR)); \
!op_iter_done (&(ITER)); \
op_iter_next_maydef (&(USEVAR), &(DEFVAR), &(ITER)))
#endif /* GCC_TREE_SSA_OPERANDS_H */ #endif /* GCC_TREE_SSA_OPERANDS_H */
gcc/tree-ssa.c
...@@ -504,6 +504,8 @@ verify_ssa (void) ...@@ -504,6 +504,8 @@ verify_ssa (void)
size_t i; size_t i;
basic_block bb; basic_block bb;
basic_block *definition_block = xcalloc (num_ssa_names, sizeof (basic_block)); basic_block *definition_block = xcalloc (num_ssa_names, sizeof (basic_block));
ssa_op_iter iter;
tree op;
timevar_push (TV_TREE_SSA_VERIFY); timevar_push (TV_TREE_SSA_VERIFY);
...@@ -528,43 +530,26 @@ verify_ssa (void) ...@@ -528,43 +530,26 @@ verify_ssa (void)
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi)) for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
{ {
tree stmt; tree stmt;
stmt_ann_t ann;
unsigned int j;
v_may_def_optype v_may_defs;
v_must_def_optype v_must_defs;
def_optype defs;
stmt = bsi_stmt (bsi); stmt = bsi_stmt (bsi);
ann = stmt_ann (stmt);
get_stmt_operands (stmt); get_stmt_operands (stmt);
v_may_defs = V_MAY_DEF_OPS (ann); if (stmt_ann (stmt)->makes_aliased_stores
if (ann->makes_aliased_stores && NUM_V_MAY_DEFS (v_may_defs) == 0) && NUM_V_MAY_DEFS (STMT_V_MAY_DEF_OPS (stmt)) == 0)
{ {
error ("Statement makes aliased stores, but has no V_MAY_DEFS"); error ("Statement makes aliased stores, but has no V_MAY_DEFS");
debug_generic_stmt (stmt); debug_generic_stmt (stmt);
goto err; goto err;
} }
for (j = 0; j < NUM_V_MAY_DEFS (v_may_defs); j++) FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_VIRTUAL_DEFS)
{ {
tree op = V_MAY_DEF_RESULT (v_may_defs, j);
if (verify_def (bb, definition_block, op, stmt, true)) if (verify_def (bb, definition_block, op, stmt, true))
goto err; goto err;
} }
v_must_defs = STMT_V_MUST_DEF_OPS (stmt); FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_DEF)
for (j = 0; j < NUM_V_MUST_DEFS (v_must_defs); j++)
{ {
tree op = V_MUST_DEF_OP (v_must_defs, j);
if (verify_def (bb, definition_block, op, stmt, true))
goto err;
}
defs = DEF_OPS (ann);
for (j = 0; j < NUM_DEFS (defs); j++)
{
tree op = DEF_OP (defs, j);
if (verify_def (bb, definition_block, op, stmt, false)) if (verify_def (bb, definition_block, op, stmt, false))
goto err; goto err;
} }
...@@ -600,34 +585,16 @@ verify_ssa (void) ...@@ -600,34 +585,16 @@ verify_ssa (void)
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi)) for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
{ {
tree stmt = bsi_stmt (bsi); tree stmt = bsi_stmt (bsi);
stmt_ann_t ann = stmt_ann (stmt);
unsigned int j;
vuse_optype vuses;
v_may_def_optype v_may_defs;
use_optype uses;
vuses = VUSE_OPS (ann);
for (j = 0; j < NUM_VUSES (vuses); j++)
{
tree op = VUSE_OP (vuses, j);
if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
op, stmt, false, true))
goto err;
}
v_may_defs = V_MAY_DEF_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_VIRTUAL_USES)
for (j = 0; j < NUM_V_MAY_DEFS (v_may_defs); j++)
{ {
tree op = V_MAY_DEF_OP (v_may_defs, j);
if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)], if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
op, stmt, false, true)) op, stmt, false, true))
goto err; goto err;
} }
uses = USE_OPS (ann); FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
for (j = 0; j < NUM_USES (uses); j++)
{ {
tree op = USE_OP (uses, j);
if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)], if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
op, stmt, false, false)) op, stmt, false, false))
goto err; goto err;
...@@ -941,14 +908,13 @@ propagate_into_addr (tree stmt, tree var, tree *x, tree repl) ...@@ -941,14 +908,13 @@ propagate_into_addr (tree stmt, tree var, tree *x, tree repl)
static void static void
replace_immediate_uses (tree var, tree repl) replace_immediate_uses (tree var, tree repl)
{ {
use_optype uses;
vuse_optype vuses;
v_may_def_optype v_may_defs;
int i, j, n; int i, j, n;
dataflow_t df; dataflow_t df;
tree stmt; tree stmt;
stmt_ann_t ann; stmt_ann_t ann;
bool mark_new_vars; bool mark_new_vars;
ssa_op_iter iter;
use_operand_p use_p;
df = get_immediate_uses (SSA_NAME_DEF_STMT (var)); df = get_immediate_uses (SSA_NAME_DEF_STMT (var));
n = num_immediate_uses (df); n = num_immediate_uses (df);
...@@ -982,25 +948,18 @@ replace_immediate_uses (tree var, tree repl) ...@@ -982,25 +948,18 @@ replace_immediate_uses (tree var, tree repl)
propagate_into_addr (stmt, var, &TREE_OPERAND (stmt, 1), repl); propagate_into_addr (stmt, var, &TREE_OPERAND (stmt, 1), repl);
} }
uses = USE_OPS (ann); FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
for (j = 0; j < (int) NUM_USES (uses); j++) if (USE_FROM_PTR (use_p) == var)
if (USE_OP (uses, j) == var)
{ {
propagate_value (USE_OP_PTR (uses, j), repl); propagate_value (use_p, repl);
mark_new_vars = POINTER_TYPE_P (TREE_TYPE (repl)); mark_new_vars = POINTER_TYPE_P (TREE_TYPE (repl));
} }
} }
else else
{ {
vuses = VUSE_OPS (ann); FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_VIRTUAL_USES)
for (j = 0; j < (int) NUM_VUSES (vuses); j++) if (USE_FROM_PTR (use_p) == var)
if (VUSE_OP (vuses, j) == var) propagate_value (use_p, repl);
propagate_value (VUSE_OP_PTR (vuses, j), repl);
v_may_defs = V_MAY_DEF_OPS (ann);
for (j = 0; j < (int) NUM_V_MAY_DEFS (v_may_defs); j++)
if (V_MAY_DEF_OP (v_may_defs, j) == var)
propagate_value (V_MAY_DEF_OP_PTR (v_may_defs, j), repl);
} }
/* If REPL is a pointer, it may have different memory tags associated /* If REPL is a pointer, it may have different memory tags associated
......
gcc/tree-ssanames.c
...@@ -296,25 +296,11 @@ duplicate_ssa_name (tree name, tree stmt) ...@@ -296,25 +296,11 @@ duplicate_ssa_name (tree name, tree stmt)
void void
release_defs (tree stmt) release_defs (tree stmt)
{ {
size_t i; tree def;
v_may_def_optype v_may_defs; ssa_op_iter iter;
v_must_def_optype v_must_defs;
def_optype defs;
stmt_ann_t ann;
ann = stmt_ann (stmt); FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS)
defs = DEF_OPS (ann); release_ssa_name (def);
v_may_defs = V_MAY_DEF_OPS (ann);
v_must_defs = V_MUST_DEF_OPS (ann);
for (i = 0; i < NUM_DEFS (defs); i++)
release_ssa_name (DEF_OP (defs, i));
for (i = 0; i < NUM_V_MAY_DEFS (v_may_defs); i++)
release_ssa_name (V_MAY_DEF_RESULT (v_may_defs, i));
for (i = 0; i < NUM_V_MUST_DEFS (v_must_defs); i++)
release_ssa_name (V_MUST_DEF_OP (v_must_defs, i));
} }
......
gcc/tree-vectorizer.c
...@@ -674,11 +674,6 @@ vect_create_data_ref (tree stmt, block_stmt_iterator *bsi) ...@@ -674,11 +674,6 @@ vect_create_data_ref (tree stmt, block_stmt_iterator *bsi)
tree vect_ptr_type; tree vect_ptr_type;
tree vect_ptr; tree vect_ptr;
tree addr_ref; tree addr_ref;
v_may_def_optype v_may_defs = STMT_V_MAY_DEF_OPS (stmt);
v_must_def_optype v_must_defs = STMT_V_MUST_DEF_OPS (stmt);
vuse_optype vuses = STMT_VUSE_OPS (stmt);
int nvuses, nv_may_defs, nv_must_defs;
int i;
struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info); struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info);
tree array_type; tree array_type;
tree base_addr = NULL_TREE; tree base_addr = NULL_TREE;
...@@ -687,6 +682,8 @@ vect_create_data_ref (tree stmt, block_stmt_iterator *bsi) ...@@ -687,6 +682,8 @@ vect_create_data_ref (tree stmt, block_stmt_iterator *bsi)
tree tag; tree tag;
tree addr_expr; tree addr_expr;
tree scalar_ptr_type; tree scalar_ptr_type;
tree use;
ssa_op_iter iter;
/* FORNOW: make sure the data reference is aligned. */ /* FORNOW: make sure the data reference is aligned. */
vect_align_data_ref (stmt); vect_align_data_ref (stmt);
...@@ -743,27 +740,12 @@ vect_create_data_ref (tree stmt, block_stmt_iterator *bsi) ...@@ -743,27 +740,12 @@ vect_create_data_ref (tree stmt, block_stmt_iterator *bsi)
/* Mark for renaming all aliased variables /* Mark for renaming all aliased variables
(i.e, the may-aliases of the type-mem-tag) */ (i.e, the may-aliases of the type-mem-tag) */
nvuses = NUM_VUSES (vuses); FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter,
nv_may_defs = NUM_V_MAY_DEFS (v_may_defs); (SSA_OP_VIRTUAL_DEFS | SSA_OP_VUSE))
nv_must_defs = NUM_V_MUST_DEFS (v_must_defs);
for (i = 0; i < nvuses; i++)
{ {
tree use = VUSE_OP (vuses, i);
if (TREE_CODE (use) == SSA_NAME) if (TREE_CODE (use) == SSA_NAME)
bitmap_set_bit (vars_to_rename, var_ann (SSA_NAME_VAR (use))->uid); bitmap_set_bit (vars_to_rename, var_ann (SSA_NAME_VAR (use))->uid);
} }
for (i = 0; i < nv_may_defs; i++)
{
tree def = V_MAY_DEF_RESULT (v_may_defs, i);
if (TREE_CODE (def) == SSA_NAME)
bitmap_set_bit (vars_to_rename, var_ann (SSA_NAME_VAR (def))->uid);
}
for (i = 0; i < nv_must_defs; i++)
{
tree def = V_MUST_DEF_OP (v_must_defs, i);
if (TREE_CODE (def) == SSA_NAME)
bitmap_set_bit (vars_to_rename, var_ann (SSA_NAME_VAR (def))->uid);
}
pe = loop_preheader_edge (loop); pe = loop_preheader_edge (loop);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment