[mem-ssa]: Rename *MAYDEF* to *VDEF*
Aldy Hernandez
aldyh@redhat.com
Tue Mar 28 20:21:00 GMT 2006
This patch renames the MAYDEF business to VDEF.
Tested on x86_64-linux.
Diego approved this. Committing to branch.
* testsuite/gcc.dg/tree-ssa/20040517-1.c: Rename V_MAY_DEF to VDEF.
* testsuite/gcc.dg/tree-ssa/pr26421.c: Same.
* testsuite/gcc.dg/tree-ssa/inline_asm-1.c: Same.
* testsuite/gcc.dg/tree-ssa/pr23382.c: Same.
* testsuite/gcc.dg/tree-ssa/inline_asm-2.c: Same.
* testsuite/gcc.dg/tree-ssa/20031015-1.c: Same.
* testsuite/gcc.dg/tree-ssa/alias-12.c: Same.
* tree-ssa-operands.h: Rename all *maydef* globals to *vdef*.
Rename all *MAYDEF* macros to VDEF*.
Adjust all SSA_OP_* macros accordingly.
Adjust all comments to reflect *vdef* renaming.
* tree-into-ssa.c (mark_def_sites): Rename *MAYDEF* to *VDEF*.
* tree-pretty-print.c (dump_vops): Same.
* tree.h: Same.
* tree-ssa-dse.c (dse_optimize_stmt): Same.
* tree-gimple.c (is_gimple_reg_rhs): Same.
* tree-ssa-ccp.c (visit_assignment): Same.
* tree-ssa-dom.c (eliminate_redundant_computations): Same.
(cprop_operand): Same.
(optimize_stmt): Same.
* tree-ssa-propagate.c (ssa_propagate): Same.
(stmt_makes_single_load): Same.
(stmt_makes_single_store): Same.
(replace_uses_in): Same.
* tree-ssa-alias.c (recalculate_used_alone): Same.
(group_aliases): Same.
(setup_pointers_and_addressables): Same.
* tree-ssa-sink.c (all_immediate_uses_same_place): Same.
(is_hidden_global_store): Same.
(statement_sink_location): Same.
* tree-flow-inline.h (op_iter_next_use):Same.
Rename op_iter_init_maydef to op_iter_init_vdef.
Remove op_iter_init_must_and_may_def.
(op_iter_next_def): Rename *MAYDEF* to *VDEF*.
(op_iter_next_tree): Same.
(clear_and_done_ssa_iter): Same.
(op_iter_init): Same.
(op_iter_init_tree): Same.
(op_iter_next_mustdef): Same.
* tree-dfa.c (dump_dfa_stats): Same.
(collect_dfa_stats_r): Same.
(mark_new_vars_to_rename): Same.
* tree-ssa-pre.c (compute_rvuse_and_antic_safe): Same.
(remove_dead_inserted_code): Same.
* tree-ssa-live.c (create_ssa_var_map): Same.
* tree-sra.c (decide_instantiations): Same.
* tree-ssa-copy.c (dump_copy_of): Same.
(copy_prop_visit_assignment): Same.
* tree-ssa-dce.c (propagate_necessity): Same.
* tree-ssa.c (verify_ssa_name): Same.
(verify_ssa): Same.
* tree-vect-transform.c (vectorizable_store): Same.
(vect_generate_tmps_on_preheader): Same.
* tree-outof-ssa.c (coalesce_vars): Same.
(check_replaceable): Same.
* tree-flow.h: Same.
* tree-ssa-structalias.c (update_alias_info): Same.
* tree-ssa-operands.c: Rename *v_may_def* to *vdef*.
(realloc_maydef): Rename to realloc_vdef.
(finalize_ssa_v_may_def_ops): Rename to finalize_ssa_vdef_ops.
(finalize_ssa_v_may_defs): Rename to finalize_ssa_vdefs.
(cleanup_v_may_defs): Rename to cleanup_vdefs.
(append_v_may_def): Rename to append_vdef.
(init_ssa_operands): Rename *MAYDEF* to *VDEF*.
(fini_ssa_operands): Same.
(alloc_use): Same.
(add_vuse_op): Same.
(add_maydef_op): Rename to add_vdef_op.
(realloc_maydef): Rename *MAYDEF* to *VDEF*.
(realloc_vuse): Same.
(finalize_ssa_uses): Same.
(finalize_ssa_vuse_ops): Same.
(finalize_ssa_vuses): Same.
(finalize_ssa_stmt_operands): Same.
(start_ssa_stmt_operands): Same.
(append_use): Same.
(append_vuse): Same.
(add_virtual_operand): Same.
(add_call_clobber_ops): Same.
(get_call_expr_operands): Same.
(get_modify_expr_operands): Same.
(build_ssa_operands): Same.
(free_ssa_operands): Same.
(copy_virtual_operands): Same.
(create_ssa_artficial_load_stmt): Same.
Index: tree-ssa-operands.h
===================================================================
--- tree-ssa-operands.h (revision 112415)
+++ tree-ssa-operands.h (working copy)
@@ -86,14 +86,14 @@ typedef struct vuse_vec_d *vuse_vec_p;
#define VUSE_ELEMENT_PTR(V,X) VUSE_ELEMENT_PTR_NC(V,X)
#define VUSE_ELEMENT_VAR(V,X) (VUSE_VECT_ELEMENT ((V),(X)).use_var)
-/* This represents the MAY_DEFS for a stmt. */
-struct maydef_optype_d
+/* This represents the VDEFS for a stmt. */
+struct vdef_optype_d
{
- struct maydef_optype_d *next;
+ struct vdef_optype_d *next;
tree def_var;
vuse_vec_t usev;
};
-typedef struct maydef_optype_d *maydef_optype_p;
+typedef struct vdef_optype_d *vdef_optype_p;
/* This represents the VUSEs for a stmt. */
struct vuse_optype_d
@@ -120,8 +120,8 @@ struct stmt_operands_d
struct def_optype_d * def_ops;
struct use_optype_d * use_ops;
- /* Virtual operands (V_MAY_DEF, VUSE). */
- struct maydef_optype_d * maydef_ops;
+ /* Virtual operands (VDEF, VUSE). */
+ struct vdef_optype_d * vdef_ops;
struct vuse_optype_d * vuse_ops;
};
@@ -137,7 +137,7 @@ typedef struct stmt_operands_d *stmt_ope
#define DEF_OPS(STMT) (stmt_ann (STMT)->operands.def_ops)
#define USE_OPS(STMT) (stmt_ann (STMT)->operands.use_ops)
#define VUSE_OPS(STMT) (stmt_ann (STMT)->operands.vuse_ops)
-#define MAYDEF_OPS(STMT) (stmt_ann (STMT)->operands.maydef_ops)
+#define VDEF_OPS(STMT) (stmt_ann (STMT)->operands.vdef_ops)
#define USE_OP_PTR(OP) (&((OP)->use_ptr))
#define USE_OP(OP) (USE_FROM_PTR (USE_OP_PTR (OP)))
@@ -150,12 +150,12 @@ typedef struct stmt_operands_d *stmt_ope
#define VUSE_NUM(OP) VUSE_VECT_NUM_ELEM ((OP)->usev)
#define VUSE_VECT(OP) &((OP)->usev)
-#define MAYDEF_RESULT_PTR(OP) (&((OP)->def_var))
-#define MAYDEF_RESULT(OP) ((OP)->def_var)
-#define MAYDEF_OP_PTR(OP,X) VUSE_OP_PTR (OP, X)
-#define MAYDEF_OP(OP,X) VUSE_OP (OP, X)
-#define MAYDEF_NUM(OP) VUSE_VECT_NUM_ELEM ((OP)->usev)
-#define MAYDEF_VECT(OP) &((OP)->usev)
+#define VDEF_RESULT_PTR(OP) (&((OP)->def_var))
+#define VDEF_RESULT(OP) ((OP)->def_var)
+#define VDEF_OP_PTR(OP,X) VUSE_OP_PTR (OP, X)
+#define VDEF_OP(OP,X) VUSE_OP (OP, X)
+#define VDEF_NUM(OP) VUSE_VECT_NUM_ELEM ((OP)->usev)
+#define VDEF_VECT(OP) &((OP)->usev)
#define PHI_RESULT_PTR(PHI) get_phi_result_ptr (PHI)
#define PHI_RESULT(PHI) DEF_FROM_PTR (PHI_RESULT_PTR (PHI))
@@ -172,7 +172,7 @@ typedef struct stmt_operands_d *stmt_ope
#define PHI_ARG_INDEX_FROM_USE(USE) phi_arg_index_from_use (USE)
-extern struct maydef_optype_d *realloc_maydef (struct maydef_optype_d *, int);
+extern struct vdef_optype_d *realloc_vdef (struct vdef_optype_d *, int);
extern struct vuse_optype_d *realloc_vuse (struct vuse_optype_d *, int);
extern void init_ssa_operands (void);
@@ -198,7 +198,7 @@ enum ssa_op_iter_type {
ssa_op_iter_tree,
ssa_op_iter_use,
ssa_op_iter_def,
- ssa_op_iter_maymustdef
+ ssa_op_iter_vdef
};
/* This structure is used in the operand iterator loops. It contains the
items required to determine which operand is retrieved next. During
@@ -210,8 +210,8 @@ typedef struct ssa_operand_iterator_d
def_optype_p defs;
use_optype_p uses;
vuse_optype_p vuses;
- maydef_optype_p maydefs;
- maydef_optype_p mayuses;
+ vdef_optype_p vdefs;
+ vdef_optype_p mayuses;
enum ssa_op_iter_type iter_type;
int phi_i;
int num_phi;
@@ -226,12 +226,12 @@ typedef struct ssa_operand_iterator_d
#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_VMAYUSE 0x08 /* USE portion of VDEFS. */
+#define SSA_OP_VDEF 0x10 /* DEF portion of VDEFS. */
/* These are commonly grouped operand flags. */
#define SSA_OP_VIRTUAL_USES (SSA_OP_VUSE | SSA_OP_VMAYUSE)
-#define SSA_OP_VIRTUAL_DEFS (SSA_OP_VMAYDEF)
+#define SSA_OP_VIRTUAL_DEFS (SSA_OP_VDEF)
#define SSA_OP_ALL_VIRTUALS (SSA_OP_VIRTUAL_USES | SSA_OP_VIRTUAL_DEFS)
#define SSA_OP_ALL_USES (SSA_OP_VIRTUAL_USES | SSA_OP_USE)
#define SSA_OP_ALL_DEFS (SSA_OP_VIRTUAL_DEFS | SSA_OP_DEF)
@@ -261,21 +261,13 @@ typedef struct ssa_operand_iterator_d
!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.
+/* This macro executes a loop over the VDEF operands of STMT. The def
+ and use for each VDEF 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)); \
+#define FOR_EACH_SSA_VDEF_OPERAND(DEFVAR, USEVAR, STMT, ITER) \
+ for (op_iter_init_vdef (&(ITER), STMT, &(USEVAR), &(DEFVAR)); \
!op_iter_done (&(ITER)); \
- op_iter_next_maymustdef (&(USEVAR), &(DEFVAR), &(ITER)))
-
-/* This macro executes a loop over the V_{MUST,MAY}_DEF of STMT. The def
- and kill for each V_{MUST,MAY}_DEF is returned in DEFVAR and KILLVAR.
- ITER is an ssa_op_iter structure used to control the loop. */
-#define FOR_EACH_SSA_MUST_AND_MAY_DEF_OPERAND(DEFVAR, KILLVAR, STMT, ITER)\
- for (op_iter_init_must_and_may_def (&(ITER), STMT, &(KILLVAR), &(DEFVAR));\
- !op_iter_done (&(ITER)); \
- op_iter_next_maymustdef (&(KILLVAR), &(DEFVAR), &(ITER)))
+ op_iter_next_vdef (&(USEVAR), &(DEFVAR), &(ITER)))
/* This macro will execute a loop over all the arguments of a PHI which
match FLAGS. A use_operand_p is always returned via USEVAR. FLAGS
Index: tree-into-ssa.c
===================================================================
--- tree-into-ssa.c (revision 112415)
+++ tree-into-ssa.c (working copy)
@@ -658,11 +658,11 @@ mark_def_sites (struct dom_walk_data *wa
}
/* Note that virtual definitions are irrelevant for computing KILLS
- because a V_MAY_DEF does not constitute a killing definition of the
+ because a VDEF does not constitute a killing definition of the
variable. However, the operand of a virtual definitions is a use
of the variable, so it may cause the variable to be considered
live-on-entry. */
- FOR_EACH_SSA_MAYDEF_OPERAND (def_p, vv, stmt, iter)
+ FOR_EACH_SSA_VDEF_OPERAND (def_p, vv, stmt, iter)
{
tree sym;
gcc_assert (VUSE_VECT_NUM_ELEM (*vv) == 1);
@@ -676,7 +676,7 @@ mark_def_sites (struct dom_walk_data *wa
}
/* Now process the defs and vdefs made by this statement. */
- FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_DEF | SSA_OP_VMAYDEF)
+ FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_DEF | SSA_OP_VDEF)
{
gcc_assert (DECL_P (def));
set_def_block (def, bb, false);
Index: tree-pretty-print.c
===================================================================
--- tree-pretty-print.c (revision 112415)
+++ tree-pretty-print.c (working copy)
@@ -2577,14 +2577,14 @@ dump_vops (pretty_printer *buffer, tree
if (!ssa_operands_active ())
return;
- FOR_EACH_SSA_MAYDEF_OPERAND (def_p, vv, stmt, iter)
+ FOR_EACH_SSA_VDEF_OPERAND (def_p, vv, stmt, iter)
{
gcc_assert (VUSE_VECT_NUM_ELEM (*vv) == 1);
use_p = VUSE_ELEMENT_PTR (*vv, 0);
pp_string (buffer, "# ");
dump_generic_node (buffer, DEF_FROM_PTR (def_p),
spc + 2, flags, false);
- pp_string (buffer, " = V_MAY_DEF <");
+ pp_string (buffer, " = VDEF <");
dump_generic_node (buffer, USE_FROM_PTR (use_p),
spc + 2, flags, false);
pp_string (buffer, ">;");
Index: tree.h
===================================================================
--- tree.h (revision 112415)
+++ tree.h (working copy)
@@ -2316,7 +2316,7 @@ struct tree_memory_tag GTY(())
#define MTAG_GLOBAL(NODE) (TREE_MEMORY_TAG_CHECK (NODE)->mtag.is_global)
-/* This flag is true if a SMT is used as the V_MAY_DEF or VUSE operand
+/* This flag is true if a SMT is used as the VDEF or VUSE operand
directly, because the access had all of the SMT's aliases pruned
from it. */
#define SMT_USED_ALONE(NODE) (SYMBOL_MEMORY_TAG_CHECK (NODE)->mtag.is_used_alone)
Index: tree-ssa-dse.c
===================================================================
--- tree-ssa-dse.c (revision 112415)
+++ tree-ssa-dse.c (working copy)
@@ -234,7 +234,7 @@ dse_optimize_stmt (struct dom_walk_data
/* If this statement has no virtual defs, then there is nothing
to do. */
- if (ZERO_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF))
+ if (ZERO_SSA_OPERANDS (stmt, SSA_OP_VDEF))
return;
/* We know we have virtual definitions. If this is a MODIFY_EXPR that's
@@ -263,7 +263,7 @@ dse_optimize_stmt (struct dom_walk_data
want USE_STMT to refer to the one statement which uses
all of the virtual definitions from STMT. */
use_stmt = NULL;
- FOR_EACH_SSA_MUST_AND_MAY_DEF_OPERAND (var1, vv, stmt, op_iter)
+ FOR_EACH_SSA_VDEF_OPERAND (var1, vv, stmt, op_iter)
{
gcc_assert (VUSE_VECT_NUM_ELEM (*vv) == 1);
var2 = VUSE_ELEMENT_PTR (*vv, 0);
@@ -348,7 +348,7 @@ dse_optimize_stmt (struct dom_walk_data
fprintf (dump_file, "'\n");
}
/* Then we need to fix the operand of the consuming stmt. */
- FOR_EACH_SSA_MUST_AND_MAY_DEF_OPERAND (var1, vv, stmt, op_iter)
+ FOR_EACH_SSA_VDEF_OPERAND (var1, vv, stmt, op_iter)
{
gcc_assert (VUSE_VECT_NUM_ELEM (*vv) == 1);
var2 = VUSE_ELEMENT_PTR (*vv, 0);
Index: tree-gimple.c
===================================================================
--- tree-gimple.c (revision 112415)
+++ tree-gimple.c (working copy)
@@ -93,7 +93,7 @@ is_gimple_reg_rhs (tree t)
variable is only modified if evaluation of the RHS does not throw.
Don't force a temp of a non-renamable type; the copy could be
- arbitrarily expensive. Instead we will generate a V_MAY_DEF for
+ arbitrarily expensive. Instead we will generate a VDEF for
the assignment. */
if (is_gimple_reg_type (TREE_TYPE (t))
Index: testsuite/gcc.dg/tree-ssa/20040517-1.c
===================================================================
--- testsuite/gcc.dg/tree-ssa/20040517-1.c (revision 112415)
+++ testsuite/gcc.dg/tree-ssa/20040517-1.c (working copy)
@@ -17,5 +17,5 @@ void bar (void)
malloc functions may clobber global memory. Only the function result
does not alias any other pointer.
Hence, we must have a VDEF for a before and after the call to foo(). */
-/* { dg-final { scan-tree-dump-times "V_MAY_DEF" 2 "alias1"} } */
+/* { dg-final { scan-tree-dump-times "VDEF" 2 "alias1"} } */
/* { dg-final { cleanup-tree-dump "alias1" } } */
Index: testsuite/gcc.dg/tree-ssa/pr26421.c
===================================================================
--- testsuite/gcc.dg/tree-ssa/pr26421.c (revision 112415)
+++ testsuite/gcc.dg/tree-ssa/pr26421.c (working copy)
@@ -16,5 +16,5 @@ int foo(void)
return a.i;
}
-/* { dg-final { scan-tree-dump-times "V_MAY_DEF" 2 "alias1" } } */
+/* { dg-final { scan-tree-dump-times "VDEF" 2 "alias1" } } */
/* { dg-final { cleanup-tree-dump "alias1" } } */
Index: testsuite/gcc.dg/tree-ssa/inline_asm-1.c
===================================================================
--- testsuite/gcc.dg/tree-ssa/inline_asm-1.c (revision 112415)
+++ testsuite/gcc.dg/tree-ssa/inline_asm-1.c (working copy)
@@ -15,6 +15,6 @@ char f(char *a)
/* { dg-final { scan-tree-dump-times "test_function" 2 "optimized"} } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
-/* There should a V_MAY_DEF for the inline-asm. */
-/* { dg-final { scan-tree-dump-times "V_MAY_DEF" 1 "alias1"} } */
+/* There should a VDEF for the inline-asm. */
+/* { dg-final { scan-tree-dump-times "VDEF" 1 "alias1"} } */
/* { dg-final { cleanup-tree-dump "alias1" } } */
Index: testsuite/gcc.dg/tree-ssa/pr23382.c
===================================================================
--- testsuite/gcc.dg/tree-ssa/pr23382.c (revision 112415)
+++ testsuite/gcc.dg/tree-ssa/pr23382.c (working copy)
@@ -12,11 +12,11 @@ void f(void)
{
struct a *a = malloc(sizeof(struct a));
}
-/* { dg-final { scan-tree-dump-times "V_MAY_DEF <HEAP" 1 "alias1"} } */
-/* { dg-final { scan-tree-dump-times "V_MAY_DEF <HEAP" 1 "alias2"} } */
-/* { dg-final { scan-tree-dump-times "V_MAY_DEF <HEAP" 1 "alias3"} } */
-/* { dg-final { scan-tree-dump-times "V_MAY_DEF <HEAP" 1 "alias4"} } */
-/* { dg-final { scan-tree-dump-times "V_MAY_DEF <HEAP" 1 "alias5"} } */
+/* { dg-final { scan-tree-dump-times "VDEF <HEAP" 1 "alias1"} } */
+/* { dg-final { scan-tree-dump-times "VDEF <HEAP" 1 "alias2"} } */
+/* { dg-final { scan-tree-dump-times "VDEF <HEAP" 1 "alias3"} } */
+/* { dg-final { scan-tree-dump-times "VDEF <HEAP" 1 "alias4"} } */
+/* { dg-final { scan-tree-dump-times "VDEF <HEAP" 1 "alias5"} } */
/* { dg-final { cleanup-tree-dump "alias1" } } */
/* { dg-final { cleanup-tree-dump "alias2" } } */
/* { dg-final { cleanup-tree-dump "alias3" } } */
Index: testsuite/gcc.dg/tree-ssa/inline_asm-2.c
===================================================================
--- testsuite/gcc.dg/tree-ssa/inline_asm-2.c (revision 112415)
+++ testsuite/gcc.dg/tree-ssa/inline_asm-2.c (working copy)
@@ -13,6 +13,6 @@ void f(char *a)
link_error ();
}
-/* There should a V_MAY_DEF for the inline-asm and one for the link_error. */
-/* { dg-final { scan-tree-dump-times "V_MAY_DEF" 2 "alias1"} } */
+/* There should a VDEF for the inline-asm and one for the link_error. */
+/* { dg-final { scan-tree-dump-times "VDEF" 2 "alias1"} } */
/* { dg-final { cleanup-tree-dump "alias1" } } */
Index: testsuite/gcc.dg/tree-ssa/20031015-1.c
===================================================================
--- testsuite/gcc.dg/tree-ssa/20031015-1.c (revision 112415)
+++ testsuite/gcc.dg/tree-ssa/20031015-1.c (working copy)
@@ -13,6 +13,6 @@ main(void)
return 0;
}
-/* The V_*_DEF comes from the initial assignment and the asm. */
-/* { dg-final { scan-tree-dump-times "_DEF" 2 "alias1" } } */
+/* The VDEF comes from the initial assignment and the asm. */
+/* { dg-final { scan-tree-dump-times "DEF" 2 "alias1" } } */
/* { dg-final { cleanup-tree-dump "alias1" } } */
Index: testsuite/gcc.dg/tree-ssa/alias-12.c
===================================================================
--- testsuite/gcc.dg/tree-ssa/alias-12.c (revision 112415)
+++ testsuite/gcc.dg/tree-ssa/alias-12.c (working copy)
@@ -13,6 +13,6 @@ int foo(int i)
return a.x[i];
}
-/* { dg-final { scan-tree-dump "V_MAY_DEF" "alias1" } } */
+/* { dg-final { scan-tree-dump "VDEF" "alias1" } } */
/* { dg-final { cleanup-tree-dump "alias1" } } */
Index: tree-ssa-ccp.c
===================================================================
--- tree-ssa-ccp.c (revision 112415)
+++ tree-ssa-ccp.c (working copy)
@@ -127,12 +127,12 @@ Software Foundation, 51 Franklin Street,
We should be able to deduce that the predicate 'a.a != B' is always
false. To achieve this, we associate constant values to the SSA
- names in the V_MAY_DEF operands for each store. Additionally,
+ names in the VDEF operands for each store. Additionally,
since we also glob partial loads/stores with the base symbol, we
also keep track of the memory reference where the constant value
was stored (in the MEM_REF field of PROP_VALUE_T). For instance,
- # a_5 = V_MAY_DEF <a_4>
+ # a_5 = VDEF <a_4>
a.a = 2;
# VUSE <a_5>
@@ -223,7 +223,7 @@ typedef enum
/* Array of propagated constant values. After propagation,
CONST_VAL[I].VALUE holds the constant value for SSA_NAME(I). If
the constant is held in an SSA name representing a memory store
- (i.e., a V_MAY_DEF), CONST_VAL[I].MEM_REF will contain the actual
+ (i.e., a VDEF), CONST_VAL[I].MEM_REF will contain the actual
memory reference used to store (i.e., the LHS of the assignment
doing the store). */
static prop_value_t *const_val;
@@ -1248,7 +1248,7 @@ visit_assignment (tree stmt, tree *outpu
}
else if (do_store_ccp && stmt_makes_single_store (stmt))
{
- /* Otherwise, set the names in V_MAY_DEF operands to the new
+ /* Otherwise, set the names in VDEF operands to the new
constant value and mark the LHS as the memory reference
associated with VAL. */
ssa_op_iter i;
Index: tree-ssa-dom.c
===================================================================
--- tree-ssa-dom.c (revision 112415)
+++ tree-ssa-dom.c (working copy)
@@ -1454,7 +1454,7 @@ eliminate_redundant_computations (tree s
if (! def
|| TREE_CODE (def) != SSA_NAME
|| SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def)
- || !ZERO_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF)
+ || !ZERO_SSA_OPERANDS (stmt, SSA_OP_VDEF)
/* Do not record equivalences for increments of ivs. This would create
overlapping live ranges for a very questionable gain. */
|| simple_iv_increment_p (stmt))
@@ -1714,7 +1714,7 @@ cprop_operand (tree stmt, use_operand_p
known value for that SSA_NAME (or NULL if no value is known).
Propagate values from CONST_AND_COPIES into the uses, vuses and
- v_may_def_ops of STMT. */
+ vdef_ops of STMT. */
static bool
cprop_into_stmt (tree stmt)
@@ -1773,7 +1773,7 @@ optimize_stmt (struct dom_walk_data *wal
print_generic_stmt (dump_file, stmt, TDF_SLIM);
}
- /* Const/copy propagate into USES, VUSES and the RHS of V_MAY_DEFs. */
+ /* Const/copy propagate into USES, VUSES and the RHS of VDEFs. */
may_have_exposed_new_symbols = cprop_into_stmt (stmt);
/* If the statement has been modified with constant replacements,
Index: tree-ssa-propagate.c
===================================================================
--- tree-ssa-propagate.c (revision 112415)
+++ tree-ssa-propagate.c (working copy)
@@ -687,7 +687,7 @@ ssa_propagate (ssa_prop_visit_stmt_fn vi
}
-/* Return the first V_MAY_DEF operand for STMT. */
+/* Return the first VDEF operand for STMT. */
tree
first_vdef (tree stmt)
@@ -716,7 +716,7 @@ stmt_makes_single_load (tree stmt)
if (TREE_CODE (stmt) != MODIFY_EXPR)
return false;
- if (ZERO_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF|SSA_OP_VUSE))
+ if (ZERO_SSA_OPERANDS (stmt, SSA_OP_VDEF|SSA_OP_VUSE))
return false;
rhs = TREE_OPERAND (stmt, 1);
@@ -741,7 +741,7 @@ stmt_makes_single_store (tree stmt)
if (TREE_CODE (stmt) != MODIFY_EXPR)
return false;
- if (ZERO_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF))
+ if (ZERO_SSA_OPERANDS (stmt, SSA_OP_VDEF))
return false;
lhs = TREE_OPERAND (stmt, 0);
@@ -844,7 +844,7 @@ replace_uses_in (tree stmt, bool *replac
GIMPLE register, then we are making a copy/constant propagation
from a memory store. For instance,
- # a_3 = V_MAY_DEF <a_2>
+ # a_3 = VDEF <a_2>
a.b = x_1;
...
# VUSE <a_3>
@@ -855,8 +855,8 @@ replace_uses_in (tree stmt, bool *replac
the VUSE(s) that we are replacing. Otherwise, we may do the
wrong replacement:
- # a_3 = V_MAY_DEF <a_2>
- # b_5 = V_MAY_DEF <b_4>
+ # a_3 = VDEF <a_2>
+ # b_5 = VDEF <b_4>
*p = 10;
...
# VUSE <b_5>
@@ -876,10 +876,10 @@ replace_uses_in (tree stmt, bool *replac
stored in different locations:
if (...)
- # a_3 = V_MAY_DEF <a_2>
+ # a_3 = VDEF <a_2>
a.b = 3;
else
- # a_4 = V_MAY_DEF <a_2>
+ # a_4 = VDEF <a_2>
a.c = 3;
# a_5 = PHI <a_3, a_4>
Index: tree-ssa-alias.c
===================================================================
--- tree-ssa-alias.c (revision 112415)
+++ tree-ssa-alias.c (working copy)
@@ -132,7 +132,7 @@ bitmap addressable_vars;
this variable is used to represent the clobbering effects of function
calls. In these cases, all the call clobbered variables in the program
are forced to alias this variable. This reduces compile times by not
- having to keep track of too many V_MAY_DEF expressions at call sites. */
+ having to keep track of too many VDEF expressions at call sites. */
tree global_var;
DEF_VEC_I(int);
@@ -580,11 +580,11 @@ recalculate_used_alone (void)
p_6 = &b;
# p_1 = PHI <p_4(1), p_6(2)>;
- # a_7 = V_MAY_DEF <a_3>;
- # b_8 = V_MAY_DEF <b_5>;
+ # a_7 = VDEF <a_3>;
+ # b_8 = VDEF <b_5>;
*p_1 = 3;
- # a_9 = V_MAY_DEF <a_7>
+ # a_9 = VDEF <a_7>
# VUSE <b_8>
a_9 = b_8 + 2;
@@ -1436,7 +1436,7 @@ group_aliases (struct alias_info *ai)
p_5 = &a;
...
- # a_9 = V_MAY_DEF <a_8>
+ # a_9 = VDEF <a_8>
p_5->field = 0
... Several modifications to SMT.20 ...
# VUSE <a_9>
@@ -1679,7 +1679,7 @@ setup_pointers_and_addressables (struct
/* Determine whether to use .GLOBAL_VAR to model call clobbering semantics. At
- every call site, we need to emit V_MAY_DEF expressions to represent the
+ every call site, we need to emit VDEF expressions to represent the
clobbering effects of the call for variables whose address escapes the
current function.
@@ -1688,11 +1688,11 @@ setup_pointers_and_addressables (struct
(.GLOBAL_VAR). This works well, but it ties the optimizer hands because
references to any call clobbered variable is a reference to .GLOBAL_VAR.
- The second approach is to emit a clobbering V_MAY_DEF for every
- call-clobbered variable at call sites. This is the preferred way in terms
- of optimization opportunities but it may create too many V_MAY_DEF operands
- if there are many call clobbered variables and function calls in the
- function.
+ The second approach is to emit a clobbering VDEF for every
+ call-clobbered variable at call sites. This is the preferred way
+ in terms of optimization opportunities but it may create too many
+ VDEF operands if there are many call clobbered variables and
+ function calls in the function.
To decide whether or not to use .GLOBAL_VAR we multiply the number of
function calls found by the number of call-clobbered variables. If that
Index: tree-ssa-sink.c
===================================================================
--- tree-ssa-sink.c (revision 112415)
+++ tree-ssa-sink.c (working copy)
@@ -131,7 +131,7 @@ all_immediate_uses_same_place (tree stmt
return true;
}
-/* Some global stores don't necessarily have V_MAY_DEF's of global variables,
+/* Some global stores don't necessarily have VDEF's of global variables,
but we still must avoid moving them around. */
bool
@@ -156,7 +156,7 @@ is_hidden_global_store (tree stmt)
int x;
p_1 = (i_2 > 3) ? &x : p;
- # x_4 = V_MAY_DEF <x_3>
+ # x_4 = VDEF <x_3>
*p_1 = 5;
return 2;
@@ -402,7 +402,7 @@ statement_sink_location (tree stmt, basi
/* This will happen when you have
a_3 = PHI <a_13, a_26>
- a_26 = V_MAY_DEF <a_3>
+ a_26 = VDEF <a_3>
If the use is a phi, and is in the same bb as the def,
we can't sink it. */
Index: tree-flow-inline.h
===================================================================
--- tree-flow-inline.h (revision 112415)
+++ tree-flow-inline.h (working copy)
@@ -906,8 +906,8 @@ op_iter_next_use (ssa_op_iter *ptr)
}
if (ptr->mayuses)
{
- use_p = MAYDEF_OP_PTR (ptr->mayuses, ptr->mayuse_index);
- if (++(ptr->mayuse_index) >= MAYDEF_NUM (ptr->mayuses))
+ use_p = VDEF_OP_PTR (ptr->mayuses, ptr->mayuse_index);
+ if (++(ptr->mayuse_index) >= VDEF_NUM (ptr->mayuses))
{
ptr->mayuse_index = 0;
ptr->mayuses = ptr->mayuses->next;
@@ -936,10 +936,10 @@ op_iter_next_def (ssa_op_iter *ptr)
ptr->defs = ptr->defs->next;
return def_p;
}
- if (ptr->maydefs)
+ if (ptr->vdefs)
{
- def_p = MAYDEF_RESULT_PTR (ptr->maydefs);
- ptr->maydefs = ptr->maydefs->next;
+ def_p = VDEF_RESULT_PTR (ptr->vdefs);
+ ptr->vdefs = ptr->vdefs->next;
return def_p;
}
ptr->done = true;
@@ -972,8 +972,8 @@ op_iter_next_tree (ssa_op_iter *ptr)
}
if (ptr->mayuses)
{
- val = MAYDEF_OP (ptr->mayuses, ptr->mayuse_index);
- if (++(ptr->mayuse_index) >= MAYDEF_NUM (ptr->mayuses))
+ val = VDEF_OP (ptr->mayuses, ptr->mayuse_index);
+ if (++(ptr->mayuse_index) >= VDEF_NUM (ptr->mayuses))
{
ptr->mayuse_index = 0;
ptr->mayuses = ptr->mayuses->next;
@@ -986,10 +986,10 @@ op_iter_next_tree (ssa_op_iter *ptr)
ptr->defs = ptr->defs->next;
return val;
}
- if (ptr->maydefs)
+ if (ptr->vdefs)
{
- val = MAYDEF_RESULT (ptr->maydefs);
- ptr->maydefs = ptr->maydefs->next;
+ val = VDEF_RESULT (ptr->vdefs);
+ ptr->vdefs = ptr->vdefs->next;
return val;
}
@@ -1009,7 +1009,7 @@ clear_and_done_ssa_iter (ssa_op_iter *pt
ptr->defs = NULL;
ptr->uses = NULL;
ptr->vuses = NULL;
- ptr->maydefs = NULL;
+ ptr->vdefs = NULL;
ptr->mayuses = NULL;
ptr->iter_type = ssa_op_iter_none;
ptr->phi_i = 0;
@@ -1031,8 +1031,8 @@ op_iter_init (ssa_op_iter *ptr, tree stm
ptr->defs = (flags & SSA_OP_DEF) ? DEF_OPS (stmt) : NULL;
ptr->uses = (flags & SSA_OP_USE) ? USE_OPS (stmt) : NULL;
ptr->vuses = (flags & SSA_OP_VUSE) ? VUSE_OPS (stmt) : NULL;
- ptr->maydefs = (flags & SSA_OP_VMAYDEF) ? MAYDEF_OPS (stmt) : NULL;
- ptr->mayuses = (flags & SSA_OP_VMAYUSE) ? MAYDEF_OPS (stmt) : NULL;
+ ptr->vdefs = (flags & SSA_OP_VDEF) ? VDEF_OPS (stmt) : NULL;
+ ptr->mayuses = (flags & SSA_OP_VMAYUSE) ? VDEF_OPS (stmt) : NULL;
ptr->done = false;
ptr->phi_i = 0;
@@ -1077,16 +1077,16 @@ op_iter_init_tree (ssa_op_iter *ptr, tre
/* Get the next iterator mustdef value for PTR, returning the mustdef values in
KILL and DEF. */
static inline void
-op_iter_next_maymustdef (vuse_vec_p *use, def_operand_p *def,
+op_iter_next_vdef (vuse_vec_p *use, def_operand_p *def,
ssa_op_iter *ptr)
{
#ifdef ENABLE_CHECKING
- gcc_assert (ptr->iter_type == ssa_op_iter_maymustdef);
+ gcc_assert (ptr->iter_type == ssa_op_iter_vdef);
#endif
if (ptr->mayuses)
{
- *def = MAYDEF_RESULT_PTR (ptr->mayuses);
- *use = MAYDEF_VECT (ptr->mayuses);
+ *def = VDEF_RESULT_PTR (ptr->mayuses);
+ *use = VDEF_VECT (ptr->mayuses);
ptr->mayuses = ptr->mayuses->next;
return;
}
@@ -1103,7 +1103,7 @@ op_iter_next_mustdef (use_operand_p *use
ssa_op_iter *ptr)
{
vuse_vec_p vp;
- op_iter_next_maymustdef (&vp, def, ptr);
+ op_iter_next_vdef (&vp, def, ptr);
if (vp != NULL)
{
gcc_assert (VUSE_VECT_NUM_ELEM (*vp) == 1);
@@ -1116,28 +1116,14 @@ op_iter_next_mustdef (use_operand_p *use
/* 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, vuse_vec_p *use,
+op_iter_init_vdef (ssa_op_iter *ptr, tree stmt, vuse_vec_p *use,
def_operand_p *def)
{
gcc_assert (TREE_CODE (stmt) != PHI_NODE);
op_iter_init (ptr, stmt, SSA_OP_VMAYUSE);
- ptr->iter_type = ssa_op_iter_maymustdef;
- op_iter_next_maymustdef (use, def, ptr);
-}
-
-
-/* Initialize iterator PTR to the operands in STMT. Return the first operands
- in KILL and DEF. */
-static inline void
-op_iter_init_must_and_may_def (ssa_op_iter *ptr, tree stmt,
- vuse_vec_p *kill, def_operand_p *def)
-{
- gcc_assert (TREE_CODE (stmt) != PHI_NODE);
-
- op_iter_init (ptr, stmt, SSA_OP_VMAYUSE);
- ptr->iter_type = ssa_op_iter_maymustdef;
- op_iter_next_maymustdef (kill, def, ptr);
+ ptr->iter_type = ssa_op_iter_vdef;
+ op_iter_next_vdef (use, def, ptr);
}
Index: tree-dfa.c
===================================================================
--- tree-dfa.c (revision 112415)
+++ tree-dfa.c (working copy)
@@ -59,7 +59,7 @@ struct dfa_stats_d
long num_phis;
long num_phi_args;
int max_num_phi_args;
- long num_v_may_defs;
+ long num_vdefs;
long num_vuses;
};
@@ -477,9 +477,9 @@ dump_dfa_stats (FILE *file)
fprintf (file, fmt_str_1, "VUSE operands", dfa_stats.num_vuses,
SCALE (size), LABEL (size));
- size = dfa_stats.num_v_may_defs * sizeof (tree *);
+ size = dfa_stats.num_vdefs * sizeof (tree *);
total += size;
- fprintf (file, fmt_str_1, "V_MAY_DEF operands", dfa_stats.num_v_may_defs,
+ fprintf (file, fmt_str_1, "VDEF operands", dfa_stats.num_vdefs,
SCALE (size), LABEL (size));
size = dfa_stats.num_phis * sizeof (struct tree_phi_node);
@@ -574,7 +574,7 @@ collect_dfa_stats_r (tree *tp, int *walk
dfa_stats_p->num_stmt_anns++;
dfa_stats_p->num_defs += NUM_SSA_OPERANDS (t, SSA_OP_DEF);
dfa_stats_p->num_uses += NUM_SSA_OPERANDS (t, SSA_OP_USE);
- dfa_stats_p->num_v_may_defs += NUM_SSA_OPERANDS (t, SSA_OP_VMAYDEF);
+ dfa_stats_p->num_vdefs += NUM_SSA_OPERANDS (t, SSA_OP_VDEF);
dfa_stats_p->num_vuses += NUM_SSA_OPERANDS (t, SSA_OP_VUSE);
break;
}
@@ -793,7 +793,7 @@ mark_new_vars_to_rename (tree stmt)
tree val;
bitmap vars_in_vops_to_rename;
bool found_exposed_symbol = false;
- int v_may_defs_before, v_may_defs_after;
+ int vdefs_before, vdefs_after;
if (TREE_CODE (stmt) == PHI_NODE)
return;
@@ -810,10 +810,9 @@ mark_new_vars_to_rename (tree stmt)
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
statement operands. */
- v_may_defs_before = NUM_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF);
+ vdefs_before = NUM_SSA_OPERANDS (stmt, SSA_OP_VDEF);
- FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter,
- SSA_OP_VMAYDEF | SSA_OP_VUSE)
+ FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter, SSA_OP_VDEF | SSA_OP_VUSE)
{
if (!DECL_P (val))
val = SSA_NAME_VAR (val);
@@ -824,7 +823,7 @@ mark_new_vars_to_rename (tree stmt)
exposed variables. */
update_stmt (stmt);
- v_may_defs_after = NUM_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF);
+ vdefs_after = NUM_SSA_OPERANDS (stmt, SSA_OP_VDEF);
FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter, SSA_OP_ALL_OPERANDS)
if (DECL_P (val))
@@ -839,7 +838,7 @@ mark_new_vars_to_rename (tree stmt)
vanishing VDEFs because in those cases, the names that were formerly
generated by this statement are not going to be available anymore. */
if (found_exposed_symbol
- || v_may_defs_before > v_may_defs_after)
+ || vdefs_before > vdefs_after)
mark_set_for_renaming (vars_in_vops_to_rename);
BITMAP_FREE (vars_in_vops_to_rename);
Index: tree-ssa-pre.c
===================================================================
--- tree-ssa-pre.c (revision 112415)
+++ tree-ssa-pre.c (working copy)
@@ -1916,7 +1916,7 @@ compute_rvuse_and_antic_safe (void)
tree stmt = bsi_stmt (bsi);
if (first_store_uid[bb->index] == 0
- && !ZERO_SSA_OPERANDS (stmt, SSA_OP_VMAYUSE | SSA_OP_VMAYDEF))
+ && !ZERO_SSA_OPERANDS (stmt, SSA_OP_VMAYUSE | SSA_OP_VDEF))
{
first_store_uid[bb->index] = stmt_ann (stmt)->uid;
}
@@ -3549,14 +3549,14 @@ remove_dead_inserted_code (void)
else
{
/* Propagate through the operands. Examine all the USE, VUSE and
- V_MAY_DEF operands in this statement. Mark all the statements
+ VDEF operands in this statement. Mark all the statements
which feed this statement's uses as necessary. */
ssa_op_iter iter;
tree use;
- /* The operands of V_MAY_DEF expressions are also needed as they
+ /* The operands of VDEF expressions are also needed as they
represent potential definitions that may reach this
- statement (V_MAY_DEF operands allow us to follow def-def
+ statement (VDEF operands allow us to follow def-def
links). */
FOR_EACH_SSA_TREE_OPERAND (use, t, iter, SSA_OP_ALL_USES)
Index: tree-ssa-live.c
===================================================================
--- tree-ssa-live.c (revision 112415)
+++ tree-ssa-live.c (working copy)
@@ -472,7 +472,7 @@ create_ssa_var_map (int flags)
#ifdef ENABLE_CHECKING
/* Validate that virtual ops don't get used in funny ways. */
FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter,
- SSA_OP_VIRTUAL_USES | SSA_OP_VMAYDEF)
+ SSA_OP_VIRTUAL_USES | SSA_OP_VDEF)
{
bitmap_set_bit (used_in_virtual_ops,
DECL_UID (SSA_NAME_VAR (use)));
Index: tree-sra.c
===================================================================
--- tree-sra.c (revision 112415)
+++ tree-sra.c (working copy)
@@ -1448,7 +1448,7 @@ decide_instantiations (void)
/* Phase Four: Update the function to match the replacements created. */
-/* Mark all the variables in V_MAY_DEF operands for STMT for
+/* Mark all the variables in VDEF operands for STMT for
renaming. This becomes necessary when we modify all of a non-scalar. */
static void
Index: tree-ssa-copy.c
===================================================================
--- tree-ssa-copy.c (revision 112415)
+++ tree-ssa-copy.c (working copy)
@@ -527,7 +527,7 @@ dump_copy_of (FILE *file, tree var)
/* Evaluate the RHS of STMT. If it produces a valid copy, set the LHS
value and store the LHS into *RESULT_P. If STMT generates more
than one name (i.e., STMT is an aliased store), it is enough to
- store the first name in the V_MAY_DEF list into *RESULT_P. After
+ store the first name in the VDEF list into *RESULT_P. After
all, the names generated will be VUSEd in the same statements. */
static enum ssa_prop_result
@@ -572,7 +572,7 @@ copy_prop_visit_assignment (tree stmt, t
}
else if (stmt_makes_single_store (stmt))
{
- /* Otherwise, set the names in V_MAY_DEF operands to be a copy
+ /* Otherwise, set the names in VDEF operands to be a copy
of RHS. */
ssa_op_iter i;
tree vdef;
Index: tree-ssa-dce.c
===================================================================
--- tree-ssa-dce.c (revision 112415)
+++ tree-ssa-dce.c (working copy)
@@ -539,14 +539,14 @@ propagate_necessity (struct edge_list *e
else
{
/* Propagate through the operands. Examine all the USE, VUSE and
- V_MAY_DEF operands in this statement. Mark all the statements
+ VDEF operands in this statement. Mark all the statements
which feed this statement's uses as necessary. */
ssa_op_iter iter;
tree use;
- /* The operands of V_MAY_DEF expressions are also needed as they
+ /* The operands of VDEF expressions are also needed as they
represent potential definitions that may reach this
- statement (V_MAY_DEF operands allow us to follow def-def
+ statement (VDEF operands allow us to follow def-def
links). */
FOR_EACH_SSA_TREE_OPERAND (use, i, iter, SSA_OP_ALL_USES)
Index: tree-ssa.c
===================================================================
--- tree-ssa.c (revision 112415)
+++ tree-ssa.c (working copy)
@@ -156,7 +156,7 @@ verify_ssa_name (tree ssa_name, bool is_
it means that the block in that array slot contains the
definition of SSA_NAME.
- IS_VIRTUAL is true if SSA_NAME is created by a V_MAY_DEF. */
+ IS_VIRTUAL is true if SSA_NAME is created by a VDEF. */
static bool
verify_def (basic_block bb, basic_block *definition_block, tree ssa_name,
@@ -207,7 +207,7 @@ err:
is flowing through an abnormal edge (only used when checking PHI
arguments).
- IS_VIRTUAL is true if SSA_NAME is created by a V_MAY_DEF.
+ IS_VIRTUAL is true if SSA_NAME is created by a VDEF.
If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names
that are defined before STMT in basic block BB. */
@@ -717,10 +717,9 @@ verify_ssa (bool check_modified_stmt)
if (base_address
&& SSA_VAR_P (base_address)
- && ZERO_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF))
+ && ZERO_SSA_OPERANDS (stmt, SSA_OP_VDEF))
{
- error ("statement makes a memory store, but has no "
- "V_MAY_DEFS");
+ error ("statement makes a memory store, but has no VDEFS");
print_generic_stmt (stderr, stmt, TDF_VOPS);
goto err;
}
Index: tree-vect-transform.c
===================================================================
--- tree-vect-transform.c (revision 112415)
+++ tree-vect-transform.c (working copy)
@@ -1724,13 +1724,13 @@ vectorizable_store (tree stmt, block_stm
*vec_stmt = build2 (MODIFY_EXPR, vectype, data_ref, vec_oprnd1);
vect_finish_stmt_generation (stmt, *vec_stmt, bsi);
- /* Copy the V_MAY_DEFS representing the aliasing of the original array
+ /* Copy the VDEFS representing the aliasing of the original array
element's definition to the vector's definition then update the
defining statement. The original is being deleted so the same
SSA_NAMEs can be used. */
copy_virtual_operands (*vec_stmt, stmt);
- FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_VMAYDEF)
+ FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_VDEF)
{
SSA_NAME_DEF_STMT (def) = *vec_stmt;
@@ -2373,9 +2373,9 @@ vect_generate_tmps_on_preheader (loop_ve
LOOP - the loop whose preheader will contain STMT.
It's possible to vectorize a loop even though an SSA_NAME from a VUSE
- appears to be defined in a V_MAY_DEF in another statement in a loop.
+ appears to be defined in a VDEF in another statement in a loop.
One such case is when the VUSE is at the dereference of a __restricted__
- pointer in a load and the V_MAY_DEF is at the dereference of a different
+ pointer in a load and the VDEF is at the dereference of a different
__restricted__ pointer in a store. Vectorization may result in
copy_virtual_uses being called to copy the problematic VUSE to a new
statement that is being inserted in the loop preheader. This procedure
Index: tree-outof-ssa.c
===================================================================
--- tree-outof-ssa.c (revision 112415)
+++ tree-outof-ssa.c (working copy)
@@ -1272,7 +1272,7 @@ coalesce_vars (var_map map, tree_live_in
dependent on any virtual variable (via a VUSE) has a dependence added
to the special partition defined by VIRTUAL_PARTITION.
- Whenever a V_MAY_DEF is seen, all expressions dependent this
+ Whenever a VDEF is seen, all expressions dependent this
VIRTUAL_PARTITION are removed from consideration.
At the end of a basic block, all expression are removed from consideration
@@ -1310,7 +1310,7 @@ typedef struct temp_expr_table_d
value_expr_p pending_dependence;
} *temp_expr_table_p;
-/* Used to indicate a dependency on V_MAY_DEFs. */
+/* Used to indicate a dependency on VDEFs. */
#define VIRTUAL_PARTITION(table) (table->virtual_partition)
static temp_expr_table_p new_temp_expr_table (var_map);
@@ -1572,7 +1572,7 @@ check_replaceable (temp_expr_table_p tab
return false;
/* There must be no VDEFs. */
- if (!(ZERO_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF)))
+ if (!(ZERO_SSA_OPERANDS (stmt, SSA_OP_VDEF)))
return false;
/* Float expressions must go through memory if float-store is on. */
Index: tree-flow.h
===================================================================
--- tree-flow.h (revision 112415)
+++ tree-flow.h (working copy)
@@ -181,8 +181,8 @@ struct var_ann_d GTY(())
unsigned in_vuse_list : 1;
/* Used during operand processing to determine if this variable is already
- in the v_may_def list. */
- unsigned in_v_may_def_list : 1;
+ in the vdef list. */
+ unsigned in_vdef_list : 1;
/* An artificial variable representing the memory location pointed-to by
all the pointer symbols that flow-insensitive alias analysis
Index: tree-ssa-structalias.c
===================================================================
--- tree-ssa-structalias.c (revision 112415)
+++ tree-ssa-structalias.c (working copy)
@@ -3063,7 +3063,7 @@ update_alias_info (tree stmt, struct ali
So, if the original code had no other dereferences of PTR,
the aliaser will not create memory tags for it, and when
&PTR->FLD gets propagated to INDIRECT_REF expressions, the
- memory operations will receive no V_MAY_DEF/VUSE operands.
+ memory operations will receive no VDEF/VUSE operands.
One solution would be to have count_uses_and_derefs consider
&PTR->FLD a dereference of PTR. But that is wrong, since it
@@ -3145,7 +3145,7 @@ update_alias_info (tree stmt, struct ali
}
- /* Mark variables in V_MAY_DEF operands as being written to. */
+ /* Mark variables in VDEF operands as being written to. */
FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_VIRTUAL_DEFS)
{
tree var = DECL_P (op) ? op : SSA_NAME_VAR (op);
Index: tree-ssa-operands.c
===================================================================
--- tree-ssa-operands.c (revision 112415)
+++ tree-ssa-operands.c (working copy)
@@ -103,8 +103,8 @@ static VEC(tree,heap) *build_defs;
/* Array for building all the use operands. */
static VEC(tree,heap) *build_uses;
-/* Array for building all the V_MAY_DEF operands. */
-static VEC(tree,heap) *build_v_may_defs;
+/* Array for building all the VDEF operands. */
+static VEC(tree,heap) *build_vdefs;
/* Array for building all the VUSE operands. */
static VEC(tree,heap) *build_vuses;
@@ -120,7 +120,7 @@ static void get_expr_operands (tree, tre
static def_optype_p free_defs = NULL;
static use_optype_p free_uses = NULL;
static vuse_optype_p free_vuses = NULL;
-static maydef_optype_p free_maydefs = NULL;
+static vdef_optype_p free_vdefs = NULL;
/* Return the DECL_UID of the base variable of T. */
@@ -204,8 +204,8 @@ static struct
add_call_clobber_ops. */
unsigned int clobbered_vars;
- /* Number of write-clobbers (V_MAY_DEFs) avoided by using
- not_written information. */
+ /* Number of write-clobbers (VDEFs) avoided by using not_written
+ information. */
unsigned int static_write_clobbers_avoided;
/* Number of reads (VUSEs) avoided by using not_read information. */
@@ -232,7 +232,7 @@ init_ssa_operands (void)
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_vdefs = VEC_alloc (tree, heap, 25);
gcc_assert (operand_memory == NULL);
operand_memory_index = SSA_OPERAND_MEMORY_SIZE;
@@ -249,12 +249,12 @@ fini_ssa_operands (void)
struct ssa_operand_memory_d *ptr;
VEC_free (tree, heap, build_defs);
VEC_free (tree, heap, build_uses);
- VEC_free (tree, heap, build_v_may_defs);
+ VEC_free (tree, heap, build_vdefs);
VEC_free (tree, heap, build_vuses);
free_defs = NULL;
free_uses = NULL;
free_vuses = NULL;
- free_maydefs = NULL;
+ free_vdefs = NULL;
while ((ptr = operand_memory) != NULL)
{
operand_memory = operand_memory->next;
@@ -334,21 +334,21 @@ alloc_use (void)
-static inline struct maydef_optype_d *
-alloc_maydef (int num)
+static inline struct vdef_optype_d *
+alloc_vdef (int num)
{
- struct maydef_optype_d *ret;
+ struct vdef_optype_d *ret;
/* Eliminate free list for the moment. */
#if 0
- if (free_maydefs)
+ if (free_vdefs)
{
- ret = free_maydefs;
- free_maydefs = free_maydefs->next;
+ ret = free_vdefs;
+ free_vdefs = free_vdefs->next;
}
else
#endif
- ret = (struct maydef_optype_d *)ssa_operand_alloc (
- sizeof (struct maydef_optype_d) + (num - 1) * sizeof (vuse_element_t));
+ ret = (struct vdef_optype_d *)ssa_operand_alloc (
+ sizeof (struct vdef_optype_d) + (num - 1) * sizeof (vuse_element_t));
VUSE_VECT_NUM_ELEM (ret->usev) = num;
return ret;
}
@@ -518,48 +518,48 @@ add_vuse_op (tree stmt, tree op, int num
return new;
}
-/* Adds OP to the list of maydefs of statement STMT after LAST, and moves
+/* Adds OP to the list of vdefs of statement STMT after LAST, and moves
LAST to the new element. */
-static inline maydef_optype_p
-add_maydef_op (tree stmt, tree op, int num, maydef_optype_p *last)
+static inline vdef_optype_p
+add_vdef_op (tree stmt, tree op, int num, vdef_optype_p *last)
{
int x;
- maydef_optype_p new;
+ vdef_optype_p new;
- new = alloc_maydef (num);
- MAYDEF_RESULT (new) = op;
+ new = alloc_vdef (num);
+ VDEF_RESULT (new) = op;
for (x = 0; x < num; x++)
{
- MAYDEF_OP (new, x) = op;
- INITIALIZE_USE (MAYDEF_OP_PTR (new, x), &(MAYDEF_OP (new, x)), stmt);
+ VDEF_OP (new, x) = op;
+ INITIALIZE_USE (VDEF_OP_PTR (new, x), &(VDEF_OP (new, x)), stmt);
}
APPEND_OP_AFTER (new, *last);
return new;
}
-struct maydef_optype_d *
-realloc_maydef (struct maydef_optype_d *ptr, int num_elem)
+struct vdef_optype_d *
+realloc_vdef (struct vdef_optype_d *ptr, int num_elem)
{
int x, lim;
tree val, stmt;
- struct maydef_optype_d *ret, *tmp;
+ struct vdef_optype_d *ret, *tmp;
if (VUSE_VECT_NUM_ELEM (ptr->usev) == num_elem)
return ptr;
- val = MAYDEF_RESULT (ptr);
+ val = VDEF_RESULT (ptr);
if (TREE_CODE (val) == SSA_NAME)
val = SSA_NAME_VAR (val);
- stmt = USE_STMT (MAYDEF_OP_PTR (ptr, 0));
+ stmt = USE_STMT (VDEF_OP_PTR (ptr, 0));
/* Delink all the existing uses. */
for (x = 0; x < VUSE_VECT_NUM_ELEM (ptr->usev); x++)
{
- use_operand_p use_p = MAYDEF_OP_PTR (ptr, x);
+ use_operand_p use_p = VDEF_OP_PTR (ptr, x);
delink_imm_use (use_p);
}
@@ -572,26 +572,26 @@ realloc_maydef (struct maydef_optype_d *
/* its growing. Allocate a new one and replace the old one. */
tmp = ptr;;
- ret = add_maydef_op (stmt, val, num_elem, &ptr);
+ ret = add_vdef_op (stmt, val, num_elem, &ptr);
ptr = tmp;
lim = VUSE_VECT_NUM_ELEM (ptr->usev);
- memset (ptr, 0, sizeof (struct maydef_optype_d) + sizeof (vuse_element_t) * (lim- 1));
+ memset (ptr, 0, sizeof (struct vdef_optype_d) + sizeof (vuse_element_t) * (lim- 1));
/* Now simply remove the old one. */
- if (MAYDEF_OPS (stmt) == ptr)
+ if (VDEF_OPS (stmt) == ptr)
{
- MAYDEF_OPS (stmt) = ret;
+ VDEF_OPS (stmt) = ret;
return ret;
}
else
- for (tmp = MAYDEF_OPS (stmt);
+ for (tmp = VDEF_OPS (stmt);
tmp != NULL && tmp->next != ptr;
tmp = tmp->next)
{
tmp->next = ret;
return ret;
}
- /* The pointer passed in isnt in the stmt's maydef lists. */
+ /* The pointer passed in isnt in the stmt's vdef lists. */
gcc_unreachable ();
}
@@ -651,7 +651,7 @@ realloc_vuse (struct vuse_optype_d *ptr,
tmp->next = ret;
return ret;
}
- /* The pointer passed in isnt in the stmt's maydef lists. */
+ /* The pointer passed in isnt in the stmt's vdef lists. */
gcc_unreachable ();
}
@@ -842,57 +842,57 @@ finalize_ssa_uses (tree stmt)
}
-/* Takes elements from build_v_may_defs and turns them into maydef operands of
+/* Takes elements from build_vdefs and turns them into vdef operands of
STMT. */
static inline void
-finalize_ssa_v_may_def_ops (tree stmt)
+finalize_ssa_vdef_ops (tree stmt)
{
int x;
unsigned new_i;
- struct maydef_optype_d new_list;
- maydef_optype_p old_ops, ptr, last;
+ struct vdef_optype_d new_list;
+ vdef_optype_p old_ops, ptr, last;
tree act;
unsigned old_base, new_base;
new_list.next = NULL;
last = &new_list;
- old_ops = MAYDEF_OPS (stmt);
+ old_ops = VDEF_OPS (stmt);
new_i = 0;
- while (old_ops && new_i < VEC_length (tree, build_v_may_defs))
+ while (old_ops && new_i < VEC_length (tree, build_vdefs))
{
- act = VEC_index (tree, build_v_may_defs, new_i);
+ act = VEC_index (tree, build_vdefs, new_i);
new_base = get_name_decl (act);
- old_base = get_name_decl (MAYDEF_RESULT (old_ops));
+ old_base = get_name_decl (VDEF_RESULT (old_ops));
if (old_base == new_base)
{
/* if variables are the same, reuse this node. */
MOVE_HEAD_AFTER (old_ops, last);
for (x = 0; x < VUSE_VECT_NUM_ELEM (last->usev); x++)
- set_virtual_use_link (MAYDEF_OP_PTR (last, x), stmt);
+ set_virtual_use_link (VDEF_OP_PTR (last, x), stmt);
new_i++;
}
else if (old_base < new_base)
{
/* if old is less than new, old goes to the free list. */
for (x = 0; x < VUSE_VECT_NUM_ELEM (old_ops->usev); x++)
- delink_imm_use (MAYDEF_OP_PTR (old_ops, x));
- MOVE_HEAD_TO_FREELIST (old_ops, maydef);
+ delink_imm_use (VDEF_OP_PTR (old_ops, x));
+ MOVE_HEAD_TO_FREELIST (old_ops, vdef);
}
else
{
/* This is a new operand. */
- add_maydef_op (stmt, act, 1, &last);
+ add_vdef_op (stmt, act, 1, &last);
new_i++;
}
}
- /* If there is anything remaining in the build_v_may_defs list, simply emit it. */
- for ( ; new_i < VEC_length (tree, build_v_may_defs); new_i++)
- add_maydef_op (stmt, VEC_index (tree, build_v_may_defs, new_i), 1, &last);
+ /* If there is anything remaining in the build_vdefs list, simply emit it. */
+ for ( ; new_i < VEC_length (tree, build_vdefs); new_i++)
+ add_vdef_op (stmt, VEC_index (tree, build_vdefs, new_i), 1, &last);
last->next = NULL;
@@ -901,50 +901,50 @@ finalize_ssa_v_may_def_ops (tree stmt)
{
for (ptr = old_ops; ptr; ptr = ptr->next)
for (x = 0; x < VUSE_VECT_NUM_ELEM (ptr->usev); x++)
- delink_imm_use (MAYDEF_OP_PTR (ptr, x));
- old_ops->next = free_maydefs;
- free_maydefs = old_ops;
+ delink_imm_use (VDEF_OP_PTR (ptr, x));
+ old_ops->next = free_vdefs;
+ free_vdefs = old_ops;
}
/* Now set the stmt's operands. */
- MAYDEF_OPS (stmt) = new_list.next;
+ VDEF_OPS (stmt) = new_list.next;
#ifdef ENABLE_CHECKING
{
unsigned x = 0;
- for (ptr = MAYDEF_OPS (stmt); ptr; ptr = ptr->next)
+ for (ptr = VDEF_OPS (stmt); ptr; ptr = ptr->next)
x++;
- gcc_assert (x == VEC_length (tree, build_v_may_defs));
+ gcc_assert (x == VEC_length (tree, build_vdefs));
}
#endif
}
static void
-finalize_ssa_v_may_defs (tree stmt)
+finalize_ssa_vdefs (tree stmt)
{
- finalize_ssa_v_may_def_ops (stmt);
+ finalize_ssa_vdef_ops (stmt);
}
-/* Clear the in_list bits and empty the build array for V_MAY_DEFs. */
+/* Clear the in_list bits and empty the build array for VDEFs. */
static inline void
-cleanup_v_may_defs (void)
+cleanup_vdefs (void)
{
unsigned x, num;
- num = VEC_length (tree, build_v_may_defs);
+ num = VEC_length (tree, build_vdefs);
for (x = 0; x < num; x++)
{
- tree t = VEC_index (tree, build_v_may_defs, x);
+ tree t = VEC_index (tree, build_vdefs, x);
if (TREE_CODE (t) != SSA_NAME)
{
var_ann_t ann = var_ann (t);
- ann->in_v_may_def_list = 0;
+ ann->in_vdef_list = 0;
}
}
- VEC_truncate (tree, build_v_may_defs, 0);
+ VEC_truncate (tree, build_vdefs, 0);
}
@@ -1031,24 +1031,24 @@ finalize_ssa_vuse_ops (tree stmt)
static void
finalize_ssa_vuses (tree stmt)
{
- unsigned num, num_v_may_defs;
+ unsigned num, num_vdefs;
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 needed because V_MAY_DEFs imply a VUSE of the variable. For
+ VDEF operation for a variable 'a', then a VUSE for 'a' is
+ not needed because VDEFs imply a VUSE of the variable. For
instance, suppose that variable 'a' is aliased:
# VUSE <a_2>
- # a_3 = V_MAY_DEF <a_2>
+ # a_3 = VDEF <a_2>
a = a + 1;
The VUSE <a_2> is superfluous because it is implied by the
- V_MAY_DEF operation. */
+ VDEF operation. */
num = VEC_length (tree, build_vuses);
- num_v_may_defs = VEC_length (tree, build_v_may_defs);
+ num_vdefs = VEC_length (tree, build_vdefs);
- if (num > 0 && num_v_may_defs > 0)
+ if (num > 0 && num_vdefs > 0)
{
for (vuse_index = 0; vuse_index < VEC_length (tree, build_vuses); )
{
@@ -1058,7 +1058,7 @@ finalize_ssa_vuses (tree stmt)
{
var_ann_t ann = var_ann (vuse);
ann->in_vuse_list = 0;
- if (ann->in_v_may_def_list)
+ if (ann->in_vdef_list)
{
VEC_ordered_remove (tree, build_vuses, vuse_index);
continue;
@@ -1085,8 +1085,8 @@ finalize_ssa_vuses (tree stmt)
finalize_ssa_vuse_ops (stmt);
- /* The V_MAY_DEF build vector wasn't cleaned up because we needed it. */
- cleanup_v_may_defs ();
+ /* The VDEF build vector wasn't cleaned up because we needed it. */
+ cleanup_vdefs ();
/* Free the VUSEs build vector. */
VEC_truncate (tree, build_vuses, 0);
@@ -1101,7 +1101,7 @@ finalize_ssa_stmt_operands (tree stmt)
{
finalize_ssa_defs (stmt);
finalize_ssa_uses (stmt);
- finalize_ssa_v_may_defs (stmt);
+ finalize_ssa_vdefs (stmt);
finalize_ssa_vuses (stmt);
}
@@ -1114,7 +1114,7 @@ start_ssa_stmt_operands (void)
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_vdefs) == 0);
}
@@ -1136,22 +1136,22 @@ append_use (tree *use_p)
}
-/* Add a new virtual may def for variable VAR to the build array. */
+/* Add a new virtual def for variable VAR to the build array. */
static inline void
-append_v_may_def (tree var)
+append_vdef (tree var)
{
if (TREE_CODE (var) != SSA_NAME)
{
var_ann_t ann = get_var_ann (var);
/* Don't allow duplicate entries. */
- if (ann->in_v_may_def_list)
+ if (ann->in_vdef_list)
return;
- ann->in_v_may_def_list = 1;
+ ann->in_vdef_list = 1;
}
- VEC_safe_push (tree, heap, build_v_may_defs, (tree)var);
+ VEC_safe_push (tree, heap, build_vdefs, (tree)var);
}
@@ -1165,7 +1165,7 @@ append_vuse (tree var)
{
var_ann_t ann = get_var_ann (var);
- if (ann->in_vuse_list || ann->in_v_may_def_list)
+ if (ann->in_vuse_list || ann->in_vdef_list)
return;
ann->in_vuse_list = 1;
}
@@ -1328,13 +1328,13 @@ add_virtual_operand (tree var, stmt_ann_
if (TREE_THIS_VOLATILE (sym) && s_ann)
s_ann->has_volatile_ops = true;
- /* If the variable cannot be modified and this is a V_MAY_DEF change
+ /* If the variable cannot be modified and this is a VDEF change
it into a VUSE. This happens when read-only variables are marked
call-clobbered and/or aliased to writable variables. So we only
check that this only happens on non-specific stores.
Note that if this is a specific store, i.e. associated with a
- modify_expr, then we can't suppress the V_MAY_DEF, lest we run
+ modify_expr, then we can't suppress the VDEF, lest we run
into validation problems.
This can happen when programs cast away const, leaving us with a
@@ -1356,7 +1356,7 @@ add_virtual_operand (tree var, stmt_ann_
{
/* The variable is not aliased or it is an alias tag. */
if (flags & opf_is_def)
- append_v_may_def (var);
+ append_vdef (var);
else
append_vuse (var);
}
@@ -1380,7 +1380,7 @@ add_virtual_operand (tree var, stmt_ann_
continue;
none_added = false;
- append_v_may_def (al);
+ append_vdef (al);
}
/* If the variable is also an alias tag, add a virtual
@@ -1408,7 +1408,7 @@ add_virtual_operand (tree var, stmt_ann_
&& TREE_CODE (var) == SYMBOL_MEMORY_TAG)
gcc_assert (SMT_USED_ALONE (var));
- append_v_may_def (var);
+ append_vdef (var);
}
}
else
@@ -1639,7 +1639,7 @@ add_call_clobber_ops (tree stmt, tree ca
or write that variable. */
not_read_b = callee ? ipa_reference_get_not_read_global (callee) : NULL;
not_written_b = callee ? ipa_reference_get_not_written_global (callee) : NULL;
- /* Add a V_MAY_DEF operand for every call clobbered variable. */
+ /* Add a VDEF operand for every call clobbered variable. */
EXECUTE_IF_SET_IN_BITMAP (call_clobbered_vars, 0, u, bi)
{
tree var = referenced_var_lookup (u);
@@ -1754,7 +1754,7 @@ get_call_expr_operands (tree stmt, tree
tree op;
int call_flags = call_expr_flags (expr);
- /* If aliases have been computed already, add V_MAY_DEF or V_USE
+ /* If aliases have been computed already, add VDEF or V_USE
operands for all the symbols that have been found to be
call-clobbered.
@@ -1894,12 +1894,12 @@ get_modify_expr_operands (tree stmt, tre
/* For the LHS, use a regular definition (OPF_IS_DEF) for GIMPLE
registers. If the LHS is a store to memory, we will need
- a preserving definition (V_MAY_DEF).
+ a preserving definition (VDEF).
Preserving definitions are those that modify a part of an
aggregate object for which no subvars have been computed (or the
reference does not correspond exactly to one of them). Stores
- through a pointer are also represented with V_MAY_DEF operators.
+ through a pointer are also represented with VDEF operators.
We used to distinguish between preserving and killing definitions.
We always emit preserving definitions now. */
@@ -2232,7 +2232,7 @@ build_ssa_operands (tree stmt)
parse_ssa_operands (stmt);
operand_build_sort_virtual (build_vuses);
- operand_build_sort_virtual (build_v_may_defs);
+ operand_build_sort_virtual (build_vdefs);
finalize_ssa_stmt_operands (stmt);
}
@@ -2245,7 +2245,7 @@ free_ssa_operands (stmt_operands_p ops)
{
ops->def_ops = NULL;
ops->use_ops = NULL;
- ops->maydef_ops = NULL;
+ ops->vdef_ops = NULL;
ops->vuse_ops = NULL;
}
@@ -2295,15 +2295,15 @@ copy_virtual_operands (tree dest, tree s
/* Copy all the virtual fields. */
FOR_EACH_SSA_TREE_OPERAND (t, src, iter, SSA_OP_VUSE)
append_vuse (t);
- FOR_EACH_SSA_TREE_OPERAND (t, src, iter, SSA_OP_VMAYDEF)
- append_v_may_def (t);
+ FOR_EACH_SSA_TREE_OPERAND (t, src, iter, SSA_OP_VDEF)
+ append_vdef (t);
if (VEC_length (tree, build_vuses) == 0
- && VEC_length (tree, build_v_may_defs) == 0)
+ && VEC_length (tree, build_vdefs) == 0)
return;
/* Now commit the virtual operands to this stmt. */
- finalize_ssa_v_may_defs (dest);
+ finalize_ssa_vdefs (dest);
finalize_ssa_vuses (dest);
/* Finally, set the field to the same values as then originals. */
@@ -2316,15 +2316,15 @@ copy_virtual_operands (tree dest, tree s
}
gcc_assert (op_iter_done (&old_iter));
- op_iter_init_maydef (&old_iter, src, &u3, &d2);
- FOR_EACH_SSA_MAYDEF_OPERAND (def_p, u4, dest, iter)
+ op_iter_init_vdef (&old_iter, src, &u3, &d2);
+ FOR_EACH_SSA_VDEF_OPERAND (def_p, u4, dest, iter)
{
gcc_assert (!op_iter_done (&old_iter));
gcc_assert (VUSE_VECT_NUM_ELEM (*u3) == 1);
gcc_assert (VUSE_VECT_NUM_ELEM (*u4) == 1);
SET_USE (VUSE_ELEMENT_PTR_NC (*u4, 0), VUSE_ELEMENT_VAR (*u3, 0));
SET_DEF (def_p, DEF_FROM_PTR (d2));
- op_iter_next_maymustdef (&u3, &d2, &old_iter);
+ op_iter_next_vdef (&u3, &d2, &old_iter);
}
gcc_assert (op_iter_done (&old_iter));
@@ -2362,23 +2362,23 @@ create_ssa_artficial_load_stmt (tree new
}
}
- for (x = 0; x < VEC_length (tree, build_v_may_defs); x++)
+ for (x = 0; x < VEC_length (tree, build_vdefs); x++)
{
- tree t = VEC_index (tree, build_v_may_defs, x);
+ tree t = VEC_index (tree, build_vdefs, x);
if (TREE_CODE (t) != SSA_NAME)
{
var_ann_t ann = var_ann (t);
- ann->in_v_may_def_list = 0;
+ ann->in_vdef_list = 0;
}
}
/* Remove any virtual operands that were found. */
- VEC_truncate (tree, build_v_may_defs, 0);
+ VEC_truncate (tree, build_vdefs, 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 on the new statement. */
- FOR_EACH_SSA_TREE_OPERAND (op, old_stmt, iter, SSA_OP_VMAYDEF)
+ VUSE of the VDEF result on the new statement. */
+ FOR_EACH_SSA_TREE_OPERAND (op, old_stmt, iter, SSA_OP_VDEF)
append_vuse (op);
/* Now build the operands for this new stmt. */
More information about the Gcc-patches
mailing list