+2007-10-28 Richard Guenther <rguenther@suse.de>
+
+ * tree-flow.h (subvar_t): Make it a VEC.
+ (struct subvar): Remove.
+ (struct var_ann_d): Use VEC(tree,gc) to store subvars.
+ * tree-flow-inline.h (get_subvar_at): Adjust iterators over
+ variable subvars.
+ * tree-into-ssa.c (mark_sym_for_renaming): Likewise.
+ * tree-nrv.c (dest_safe_for_nrv_p): Likewise.
+ * tree-ssa-alias.c (mark_aliases_call_clobbered): Likewise.
+ (set_initial_properties): Likewise.
+ (setup_pointers_and_addressables): Likewise.
+ (new_type_alias): Likewise.
+ (create_overlap_variables_for): Likewise.
+ * tree-dfa.c (dump_subvars_for): Likewise.
+ * tree-ssa-operands.c (add_vars_for_offset): Likewise.
+ (get_expr_operands): Likewise.
+ (add_to_addressable_set): Likewise.
+ * tree-ssa-structalias.c (set_uids_in_ptset): Likewise.
+
2007-10-28 Uros Bizjak <ubizjak@gmail.com>
PR tree-optimization/33920
+2007-10-28 Richard Guenther <rguenther@suse.de>
+
+ * gcc.dg/tree-ssa/alias-15.c: Adjust pattern.
+
2007-10-28 Martin Michlmayr <tbm@cyrius.com>
Uros Bizjak <ubizjak@gmail.com>
return p->b[3] - m.b.b[3];
}
-/* { dg-final { scan-tree-dump "SFT.1 created for var m offset 128" "salias" } } */
-/* { dg-final { scan-tree-dump-times "VUSE <SFT.1_" 2 "salias" } } */
+/* { dg-final { scan-tree-dump "SFT.5 created for var m offset 128" "salias" } } */
+/* { dg-final { scan-tree-dump-times "VUSE <SFT.5_" 2 "salias" } } */
/* { dg-final { cleanup-tree-dump "salias" } } */
dump_subvars_for (FILE *file, tree var)
{
subvar_t sv = get_subvars_for_var (var);
+ tree subvar;
+ unsigned int i;
if (!sv)
return;
fprintf (file, "{ ");
- for (; sv; sv = sv->next)
+ for (i = 0; VEC_iterate (tree, sv, i, subvar); ++i)
{
- print_generic_expr (file, sv->var, dump_flags);
+ print_generic_expr (file, subvar, dump_flags);
fprintf (file, " ");
}
static inline tree
get_subvar_at (tree var, unsigned HOST_WIDE_INT offset)
{
- subvar_t sv;
-
- for (sv = get_subvars_for_var (var); sv; sv = sv->next)
- if (SFT_OFFSET (sv->var) == offset)
- return sv->var;
+ subvar_t sv = get_subvars_for_var (var);
+ unsigned int i;
+ tree subvar;
+
+ /* ??? Binary search would be possible here. */
+ for (i = 0; VEC_iterate (tree, sv, i, subvar); ++i)
+ if (SFT_OFFSET (subvar) == offset)
+ return subvar;
return NULL_TREE;
}
};
-struct subvar;
-typedef struct subvar *subvar_t;
-
-/* This structure represents a fake sub-variable for a structure field. */
-struct subvar GTY(())
-{
- /* Fake variable. */
- tree var;
-
- /* Next subvar for this structure. */
- subvar_t next;
-};
+typedef VEC(tree,gc) *subvar_t;
struct var_ann_d GTY(())
{
current version of this variable (an SSA_NAME). */
tree current_def;
- /* If this variable is a structure, this fields holds a list of
- symbols representing each of the fields of the structure. */
- subvar_t subvars;
+ /* If this variable is a structure, this fields holds an array
+ of symbols representing each of the fields of the structure. */
+ VEC(tree,gc) *subvars;
/* Mask of values saying the reasons why this variable has escaped
the function. */
subvar_t svars;
if (var_can_have_subvars (sym) && (svars = get_subvars_for_var (sym)))
{
- subvar_t sv;
- for (sv = svars; sv; sv = sv->next)
- mark_sym_for_renaming (sv->var);
+ unsigned int i;
+ tree subvar;
+
+ for (i = 0; VEC_iterate (tree, svars, i, subvar); ++i)
+ mark_sym_for_renaming (subvar);
}
}
static bool
dest_safe_for_nrv_p (tree dest)
{
- subvar_t subvar;
+ subvar_t sv;
+ unsigned int i;
+ tree subvar;
while (handled_component_p (dest))
dest = TREE_OPERAND (dest, 0);
if (is_call_clobbered (dest))
return false;
- for (subvar = get_subvars_for_var (dest); subvar; subvar = subvar->next)
- if (is_call_clobbered (subvar->var))
+
+ sv = get_subvars_for_var (dest);
+ for (i = 0; VEC_iterate (tree, sv, i, subvar); ++i)
+ if (is_call_clobbered (subvar))
return false;
+
return true;
}
{
EXECUTE_IF_SET_IN_BITMAP (queued, 0, i, bi)
{
- subvar_t svars;
- svars = get_subvars_for_var (referenced_var (i));
- for (; svars; svars = svars->next)
- if (!unmodifiable_var_p (svars->var))
- mark_call_clobbered (svars->var, ta->escape_mask);
+ subvar_t svars = get_subvars_for_var (referenced_var (i));
+ unsigned int i;
+ tree subvar;
+
+ for (i = 0; VEC_iterate (tree, svars, i, subvar); ++i)
+ if (!unmodifiable_var_p (subvar))
+ mark_call_clobbered (subvar, ta->escape_mask);
}
bitmap_clear (queued);
}
{
EXECUTE_IF_SET_IN_BITMAP (queued, 0, j, bi)
{
- subvar_t svars;
- svars = get_subvars_for_var (referenced_var (j));
- for (; svars; svars = svars->next)
- if (!unmodifiable_var_p (svars->var))
- mark_call_clobbered (svars->var, pi->escape_mask);
+ subvar_t svars = get_subvars_for_var (referenced_var (j));
+ unsigned int i;
+ tree subvar;
+
+ for (i = 0; VEC_iterate (tree, svars, i, subvar); ++i)
+ if (!unmodifiable_var_p (subvar))
+ mark_call_clobbered (subvar, pi->escape_mask);
}
bitmap_clear (queued);
}
if (var_can_have_subvars (var)
&& (svars = get_subvars_for_var (var)))
{
- subvar_t sv;
+ unsigned int i;
+ tree subvar;
- for (sv = svars; sv; sv = sv->next)
+ for (i = 0; VEC_iterate (tree, svars, i, subvar); ++i)
{
if (bitmap_bit_p (gimple_addressable_vars (cfun),
- DECL_UID (sv->var)))
+ DECL_UID (subvar)))
okay_to_mark = false;
- mark_sym_for_renaming (sv->var);
+ mark_sym_for_renaming (subvar);
}
}
HOST_WIDE_INT offset, size, maxsize;
tree ref;
VEC (tree, heap) *overlaps = NULL;
- subvar_t sv;
- unsigned int len;
+ unsigned int len, i;
+ tree subvar;
+
gcc_assert (symbol_mem_tag (ptr) == NULL_TREE);
gcc_assert (!MTAG_P (var));
if (var_can_have_subvars (ref)
&& (svars = get_subvars_for_var (ref)))
{
- for (sv = svars; sv; sv = sv->next)
+ for (i = 0; VEC_iterate (tree, svars, i, subvar); ++i)
{
bool exact;
- if (overlap_subvar (offset, maxsize, sv->var, &exact))
- VEC_safe_push (tree, heap, overlaps, sv->var);
+ if (overlap_subvar (offset, maxsize, subvar, &exact))
+ VEC_safe_push (tree, heap, overlaps, subvar);
}
gcc_assert (overlaps != NULL);
}
On mem-ssa branch, the scanning for virtual operands have been
split from the rest of tree-ssa-operands, so it should be much
easier to fix this problem correctly once mem-ssa is merged. */
- for (sv = svars; sv; sv = sv->next)
- VEC_safe_push (tree, heap, overlaps, sv->var);
+ for (i = 0; VEC_iterate (tree, svars, i, subvar); ++i)
+ VEC_safe_push (tree, heap, overlaps, subvar);
gcc_assert (overlaps != NULL);
}
/* Otherwise, create the variables. */
subvars = lookup_subvars_for_var (var);
-
+ *subvars = VEC_alloc (tree, gc, VEC_length (fieldoff_s, fieldstack));
+
sort_fieldstack (fieldstack);
- for (i = VEC_length (fieldoff_s, fieldstack);
- VEC_iterate (fieldoff_s, fieldstack, --i, fo);)
+ for (i = 0; VEC_iterate (fieldoff_s, fieldstack, i, fo); ++i)
{
- subvar_t sv;
HOST_WIDE_INT fosize;
- tree currfotype;
+ tree currfotype, subvar;
fosize = TREE_INT_CST_LOW (fo->size);
currfotype = fo->type;
&& fosize == lastfosize
&& currfotype == lastfotype))
continue;
- sv = GGC_NEW (struct subvar);
- sv->next = *subvars;
- sv->var =
- create_sft (var, fo->type, fo->offset, fosize, fo->alias_set);
+ subvar = create_sft (var, fo->type, fo->offset,
+ fosize, fo->alias_set);
+ VEC_quick_push (tree, *subvars, subvar);
if (dump_file)
{
fprintf (dump_file, "structure field tag %s created for var %s",
- get_name (sv->var), get_name (var));
+ get_name (subvar), get_name (var));
fprintf (dump_file, " offset " HOST_WIDE_INT_PRINT_DEC,
- SFT_OFFSET (sv->var));
+ SFT_OFFSET (subvar));
fprintf (dump_file, " size " HOST_WIDE_INT_PRINT_DEC,
- SFT_SIZE (sv->var));
+ SFT_SIZE (subvar));
fprintf (dump_file, "\n");
}
lastfotype = currfotype;
lastfooffset = fo->offset;
lastfosize = fosize;
- *subvars = sv;
}
/* Once we have created subvars, the original is no longer call
{
bool added = false;
subvar_t sv = get_subvars_for_var (SFT_PARENT_VAR (var));
- for (; sv; sv = sv->next)
+ unsigned int i;
+ tree subvar;
+
+ for (i = 0; VEC_iterate (tree, sv, i, subvar); ++i)
{
/* Once we hit the end of the parts that could touch,
stop looking. */
if (size != -1
- && SFT_OFFSET (var) + offset + size <= SFT_OFFSET (sv->var))
+ && SFT_OFFSET (var) + offset + size <= SFT_OFFSET (subvar))
break;
- if (overlap_subvar (SFT_OFFSET (var) + offset, size, sv->var, NULL))
+ if (overlap_subvar (SFT_OFFSET (var) + offset, size, subvar, NULL))
{
added = true;
if (is_def)
- append_vdef (sv->var);
+ append_vdef (subvar);
else
- append_vuse (sv->var);
+ append_vuse (subvar);
}
}
return added;
if (var_can_have_subvars (expr)
&& (svars = get_subvars_for_var (expr)))
{
- subvar_t sv;
- for (sv = svars; sv; sv = sv->next)
- add_stmt_operand (&sv->var, s_ann, flags);
+ unsigned int i;
+ tree subvar;
+ for (i = 0; VEC_iterate (tree, svars, i, subvar); ++i)
+ add_stmt_operand (&subvar, s_ann, flags);
}
else
add_stmt_operand (expr_p, s_ann, flags);
ref = get_ref_base_and_extent (expr, &offset, &size, &maxsize);
if (SSA_VAR_P (ref) && get_subvars_for_var (ref))
{
- subvar_t sv;
subvar_t svars = get_subvars_for_var (ref);
+ unsigned int i;
+ tree subvar;
- for (sv = svars; sv; sv = sv->next)
+ for (i = 0; VEC_iterate (tree, svars, i, subvar); ++i)
{
bool exact;
- if (overlap_subvar (offset, maxsize, sv->var, &exact))
+ if (overlap_subvar (offset, maxsize, subvar, &exact))
{
int subvar_flags = flags;
none = false;
- add_stmt_operand (&sv->var, s_ann, subvar_flags);
+ add_stmt_operand (&subvar, s_ann, subvar_flags);
}
}
if (var_can_have_subvars (var)
&& (svars = get_subvars_for_var (var)))
{
- subvar_t sv;
- for (sv = svars; sv; sv = sv->next)
+ unsigned int i;
+ tree subvar;
+ for (i = 0; VEC_iterate (tree, svars, i, subvar); ++i)
{
- bitmap_set_bit (*addresses_taken, DECL_UID (sv->var));
- TREE_ADDRESSABLE (sv->var) = 1;
+ bitmap_set_bit (*addresses_taken, DECL_UID (subvar));
+ TREE_ADDRESSABLE (subvar) = 1;
}
}
else
{
unsigned int i;
bitmap_iterator bi;
- subvar_t sv;
alias_set_type ptr_alias_set = get_alias_set (TREE_TYPE (ptr));
EXECUTE_IF_SET_IN_BITMAP (from, 0, i, bi)
if (vi->has_union && get_subvars_for_var (vi->decl) != NULL)
{
+ unsigned int i;
+ tree subvar;
+ subvar_t sv = get_subvars_for_var (vi->decl);
+
/* Variables containing unions may need to be converted to
their SFT's, because SFT's can have unions and we cannot. */
- for (sv = get_subvars_for_var (vi->decl); sv; sv = sv->next)
- bitmap_set_bit (into, DECL_UID (sv->var));
+ for (i = 0; VEC_iterate (tree, sv, i, subvar); ++i)
+ bitmap_set_bit (into, DECL_UID (subvar));
}
else if (TREE_CODE (vi->decl) == VAR_DECL
|| TREE_CODE (vi->decl) == PARM_DECL
projects / gcc.git / commitdiff