mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-04-06 04:00:25 +08:00
Code Issues Packages Projects Releases Wiki Activity

tree-ssa-structalias.c (struct variable_info): Add is_global_var member.

Browse Source 
2009-06-23  Richard Guenther  <rguenther@suse.de>

	* tree-ssa-structalias.c (struct variable_info): Add is_global_var
	member.
	(var_anything, anything_tree, var_nothing, nothing_tree, var_readonly,
	readonly_tree, var_escaped, escaped_tree, var_nonlocal, nonlocal_tree,
	var_callused, callused_tree, var_storedanything, storedanything_tree,
	var_integer, integer_tree): Remove global variables.
	(new_var_info): Do not pass new id, append the new var to the
	global variable vector.
	(do_ds_constraint): Use is_global_var member of the variable-info.
	(new_scalar_tmp_constraint_exp): Adjust.
	(create_function_info_for): Likewise.
	(create_variable_info_for): Likewise.
	(find_what_var_points_to): Remove dead code.
	(init_base_vars): Simplify.
	(compute_points_to_sets): Adjust.

From-SVN: r148841
This commit is contained in:
Richard Guenther 2009-06-23 10:03:41 +00:00 committed by Richard Biener
parent efc81a892c
commit 0bbf2ffa83
2 changed files with 75 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
gcc/ChangeLog
View File

@ -1,3 +1,21 @@
2009-06-23 Richard Guenther <rguenther@suse.de>
* tree-ssa-structalias.c (struct variable_info): Add is_global_var
member.
(var_anything, anything_tree, var_nothing, nothing_tree, var_readonly,
readonly_tree, var_escaped, escaped_tree, var_nonlocal, nonlocal_tree,
var_callused, callused_tree, var_storedanything, storedanything_tree,
var_integer, integer_tree): Remove global variables.
(new_var_info): Do not pass new id, append the new var to the
global variable vector.
(do_ds_constraint): Use is_global_var member of the variable-info.
(new_scalar_tmp_constraint_exp): Adjust.
(create_function_info_for): Likewise.
(create_variable_info_for): Likewise.
(find_what_var_points_to): Remove dead code.
(init_base_vars): Simplify.
(compute_points_to_sets): Adjust.
2009-06-22 Adam Nemet <anemet@caviumnetworks.com>
* combine.c (try_combine): Dump information about the insns we're

162
gcc/tree-ssa-structalias.c
View File

@ -229,6 +229,9 @@ struct variable_info
/* True if this field may contain pointers. */
unsigned int may_have_pointers : 1;
/* True if this represents a global variable. */
unsigned int is_global_var : 1;
/* A link to the variable for the next field in this structure. */
struct variable_info *next;
@ -284,39 +287,6 @@ enum { nothing_id = 0, anything_id = 1, readonly_id = 2,
escaped_id = 3, nonlocal_id = 4, callused_id = 5,
storedanything_id = 6, integer_id = 7 };
/* Variable that represents the unknown pointer. */
static varinfo_t var_anything;
static tree anything_tree;
/* Variable that represents the NULL pointer. */
static varinfo_t var_nothing;
static tree nothing_tree;
/* Variable that represents read only memory. */
static varinfo_t var_readonly;
static tree readonly_tree;
/* Variable that represents escaped memory. */
static varinfo_t var_escaped;
static tree escaped_tree;
/* Variable that represents nonlocal memory. */
static varinfo_t var_nonlocal;
static tree nonlocal_tree;
/* Variable that represents call-used memory. */
static varinfo_t var_callused;
static tree callused_tree;
/* Variable that represents variables that are stored to anything. */
static varinfo_t var_storedanything;
static tree storedanything_tree;
/* Variable that represents integers. This is used for when people do things
like &0->a.b. */
static varinfo_t var_integer;
static tree integer_tree;
/* Lookup a heap var for FROM, and return it if we find one. */
static tree
@ -350,25 +320,34 @@ heapvar_insert (tree from, tree to)
}
/* Return a new variable info structure consisting for a variable
named NAME, and using constraint graph node NODE. */
named NAME, and using constraint graph node NODE. Append it
to the vector of variable info structures. */
static varinfo_t
new_var_info (tree t, unsigned int id, const char *name)
new_var_info (tree t, const char *name)
{
unsigned index = VEC_length (varinfo_t, varmap);
varinfo_t ret = (varinfo_t) pool_alloc (variable_info_pool);
ret->id = id;
ret->id = index;
ret->name = name;
ret->decl = t;
ret->is_artificial_var = false;
/* Vars without decl are artificial and do not have sub-variables. */
ret->is_artificial_var = (t == NULL_TREE);
ret->is_full_var = (t == NULL_TREE);
ret->is_heap_var = false;
ret->is_special_var = false;
ret->is_unknown_size_var = false;
ret->is_full_var = false;
ret->may_have_pointers = true;
ret->is_global_var = true;
if (t && DECL_P (t))
ret->is_global_var = is_global_var (t);
ret->solution = BITMAP_ALLOC (&pta_obstack);
ret->oldsolution = BITMAP_ALLOC (&oldpta_obstack);
ret->next = NULL;
VEC_safe_push (varinfo_t, heap, varmap, ret);
return ret;
}
@ -1702,7 +1681,7 @@ do_ds_constraint (constraint_t c, bitmap delta)
}
}
/* If v is a global variable then this is an escape point. */
if (is_global_var (v->decl))
if (v->is_global_var)
{
t = find (escaped_id);
if (add_graph_edge (graph, t, rhs)
@ -2682,15 +2661,13 @@ static struct constraint_expr
new_scalar_tmp_constraint_exp (const char *name)
{
struct constraint_expr tmp;
unsigned index = VEC_length (varinfo_t, varmap);
varinfo_t vi;
vi = new_var_info (NULL_TREE, index, name);
vi = new_var_info (NULL_TREE, name);
vi->offset = 0;
vi->size = -1;
vi->fullsize = -1;
vi->is_full_var = 1;
VEC_safe_push (varinfo_t, heap, varmap, vi);
tmp.var = vi->id;
tmp.type = SCALAR;
@ -4263,7 +4240,6 @@ count_num_arguments (tree decl, bool *is_varargs)
static unsigned int
create_function_info_for (tree decl, const char *name)
{
unsigned int index = VEC_length (varinfo_t, varmap);
varinfo_t vi;
tree arg;
unsigned int i;
@ -4271,12 +4247,11 @@ create_function_info_for (tree decl, const char *name)
/* Create the variable info. */
vi = new_var_info (decl, index, name);
vi = new_var_info (decl, name);
vi->offset = 0;
vi->size = 1;
vi->fullsize = count_num_arguments (decl, &is_varargs) + 1;
insert_vi_for_tree (vi->decl, vi);
VEC_safe_push (varinfo_t, heap, varmap, vi);
stats.total_vars++;
@ -4287,10 +4262,9 @@ create_function_info_for (tree decl, const char *name)
vi->fullsize = ~0;
vi->size = ~0;
vi->is_unknown_size_var = true;
return index;
return vi->id;
}
arg = DECL_ARGUMENTS (decl);
/* Set up variables for each argument. */
@ -4299,19 +4273,16 @@ create_function_info_for (tree decl, const char *name)
varinfo_t argvi;
const char *newname;
char *tempname;
unsigned int newindex;
tree argdecl = decl;
if (arg)
argdecl = arg;
newindex = VEC_length (varinfo_t, varmap);
asprintf (&tempname, "%s.arg%d", name, i-1);
newname = ggc_strdup (tempname);
free (tempname);
argvi = new_var_info (argdecl, newindex, newname);
VEC_safe_push (varinfo_t, heap, varmap, argvi);
argvi = new_var_info (argdecl, newname);
argvi->offset = i;
argvi->size = 1;
argvi->is_full_var = true;
@ -4332,7 +4303,6 @@ create_function_info_for (tree decl, const char *name)
varinfo_t resultvi;
const char *newname;
char *tempname;
unsigned int newindex;
tree resultdecl = decl;
vi->fullsize ++;
@ -4340,13 +4310,11 @@ create_function_info_for (tree decl, const char *name)
if (DECL_RESULT (decl))
resultdecl = DECL_RESULT (decl);
newindex = VEC_length (varinfo_t, varmap);
asprintf (&tempname, "%s.result", name);
newname = ggc_strdup (tempname);
free (tempname);
resultvi = new_var_info (resultdecl, newindex, newname);
VEC_safe_push (varinfo_t, heap, varmap, resultvi);
resultvi = new_var_info (resultdecl, newname);
resultvi->offset = i;
resultvi->size = 1;
resultvi->fullsize = vi->fullsize;
@ -4356,7 +4324,8 @@ create_function_info_for (tree decl, const char *name)
if (DECL_RESULT (decl))
insert_vi_for_tree (DECL_RESULT (decl), resultvi);
}
return index;
return vi->id;
}
@ -4386,7 +4355,6 @@ check_for_overlaps (VEC (fieldoff_s,heap) *fieldstack)
static unsigned int
create_variable_info_for (tree decl, const char *name)
{
unsigned int index = VEC_length (varinfo_t, varmap);
varinfo_t vi;
tree decl_type = TREE_TYPE (decl);
tree declsize = DECL_P (decl) ? DECL_SIZE (decl) : TYPE_SIZE (decl_type);
@ -4406,7 +4374,7 @@ create_variable_info_for (tree decl, const char *name)
/* If the variable doesn't have subvars, we may end up needing to
sort the field list and create fake variables for all the
fields. */
vi = new_var_info (decl, index, name);
vi = new_var_info (decl, name);
vi->offset = 0;
vi->may_have_pointers = could_have_pointers (decl);
if (!declsize
@ -4423,7 +4391,6 @@ create_variable_info_for (tree decl, const char *name)
}
insert_vi_for_tree (vi->decl, vi);
VEC_safe_push (varinfo_t, heap, varmap, vi);
if (is_global && (!flag_whole_program || !in_ipa_mode)
&& vi->may_have_pointers)
{
@ -4441,7 +4408,6 @@ create_variable_info_for (tree decl, const char *name)
&& VEC_length (fieldoff_s, fieldstack) > 1
&& VEC_length (fieldoff_s, fieldstack) <= MAX_FIELDS_FOR_FIELD_SENSITIVE)
{
unsigned int newindex = VEC_length (varinfo_t, varmap);
fieldoff_s *fo = NULL;
bool notokay = false;
unsigned int i;
@ -4481,7 +4447,7 @@ create_variable_info_for (tree decl, const char *name)
vi->size = ~0;
vi->is_full_var = true;
VEC_free (fieldoff_s, heap, fieldstack);
return index;
return vi->id;
}
vi->size = fo->size;
@ -4495,7 +4461,6 @@ create_variable_info_for (tree decl, const char *name)
const char *newname = "NULL";
char *tempname;
newindex = VEC_length (varinfo_t, varmap);
if (dump_file)
{
asprintf (&tempname, "%s." HOST_WIDE_INT_PRINT_DEC
@ -4504,13 +4469,12 @@ create_variable_info_for (tree decl, const char *name)
newname = ggc_strdup (tempname);
free (tempname);
}
newvi = new_var_info (decl, newindex, newname);
newvi = new_var_info (decl, newname);
newvi->offset = fo->offset;
newvi->size = fo->size;
newvi->fullsize = vi->fullsize;
newvi->may_have_pointers = fo->may_have_pointers;
insert_into_field_list (vi, newvi);
VEC_safe_push (varinfo_t, heap, varmap, newvi);
if (is_global && (!flag_whole_program || !in_ipa_mode)
&& newvi->may_have_pointers)
make_copy_constraint (newvi, nonlocal_id);
@ -4523,7 +4487,7 @@ create_variable_info_for (tree decl, const char *name)
VEC_free (fieldoff_s, heap, fieldstack);
return index;
return vi->id;
}
/* Print out the points-to solution for VAR to FILE. */
@ -4770,7 +4734,6 @@ find_what_var_points_to (varinfo_t vi, struct pt_solution *pt)
bitmap_iterator bi;
bitmap finished_solution;
bitmap result;
tree ptr = vi->decl;
memset (pt, 0, sizeof (struct pt_solution));
@ -4813,9 +4776,6 @@ find_what_var_points_to (varinfo_t vi, struct pt_solution *pt)
finished_solution = BITMAP_GGC_ALLOC ();
stats.points_to_sets_created++;
if (TREE_CODE (ptr) == SSA_NAME)
ptr = SSA_NAME_VAR (ptr);
set_uids_in_ptset (finished_solution, vi->solution, pt);
result = shared_bitmap_lookup (finished_solution);
if (!result)
@ -5066,24 +5026,29 @@ static void
init_base_vars (void)
{
struct constraint_expr lhs, rhs;
varinfo_t var_anything;
varinfo_t var_nothing;
varinfo_t var_readonly;
varinfo_t var_escaped;
varinfo_t var_nonlocal;
varinfo_t var_callused;
varinfo_t var_storedanything;
varinfo_t var_integer;
/* Create the NULL variable, used to represent that a variable points
to NULL. */
nothing_tree = create_tmp_var_raw (void_type_node, "NULL");
var_nothing = new_var_info (nothing_tree, nothing_id, "NULL");
insert_vi_for_tree (nothing_tree, var_nothing);
var_nothing = new_var_info (NULL_TREE, "NULL");
gcc_assert (var_nothing->id == nothing_id);
var_nothing->is_artificial_var = 1;
var_nothing->offset = 0;
var_nothing->size = ~0;
var_nothing->fullsize = ~0;
var_nothing->is_special_var = 1;
VEC_safe_push (varinfo_t, heap, varmap, var_nothing);
/* Create the ANYTHING variable, used to represent that a variable
points to some unknown piece of memory. */
anything_tree = create_tmp_var_raw (ptr_type_node, "ANYTHING");
var_anything = new_var_info (anything_tree, anything_id, "ANYTHING");
insert_vi_for_tree (anything_tree, var_anything);
var_anything = new_var_info (NULL_TREE, "ANYTHING");
gcc_assert (var_anything->id == anything_id);
var_anything->is_artificial_var = 1;
var_anything->size = ~0;
var_anything->offset = 0;
@ -5094,7 +5059,6 @@ init_base_vars (void)
/* Anything points to anything. This makes deref constraints just
work in the presence of linked list and other p = *p type loops,
by saying that *ANYTHING = ANYTHING. */
VEC_safe_push (varinfo_t, heap, varmap, var_anything);
lhs.type = SCALAR;
lhs.var = anything_id;
lhs.offset = 0;
@ -5109,16 +5073,14 @@ init_base_vars (void)
/* Create the READONLY variable, used to represent that a variable
points to readonly memory. */
readonly_tree = create_tmp_var_raw (ptr_type_node, "READONLY");
var_readonly = new_var_info (readonly_tree, readonly_id, "READONLY");
var_readonly = new_var_info (NULL_TREE, "READONLY");
gcc_assert (var_readonly->id == readonly_id);
var_readonly->is_artificial_var = 1;
var_readonly->offset = 0;
var_readonly->size = ~0;
var_readonly->fullsize = ~0;
var_readonly->next = NULL;
var_readonly->is_special_var = 1;
insert_vi_for_tree (readonly_tree, var_readonly);
VEC_safe_push (varinfo_t, heap, varmap, var_readonly);
/* readonly memory points to anything, in order to make deref
easier. In reality, it points to anything the particular
@ -5134,28 +5096,23 @@ init_base_vars (void)
/* Create the ESCAPED variable, used to represent the set of escaped
memory. */
escaped_tree = create_tmp_var_raw (ptr_type_node, "ESCAPED");
var_escaped = new_var_info (escaped_tree, escaped_id, "ESCAPED");
insert_vi_for_tree (escaped_tree, var_escaped);
var_escaped = new_var_info (NULL_TREE, "ESCAPED");
gcc_assert (var_escaped->id == escaped_id);
var_escaped->is_artificial_var = 1;
var_escaped->offset = 0;
var_escaped->size = ~0;
var_escaped->fullsize = ~0;
var_escaped->is_special_var = 0;
VEC_safe_push (varinfo_t, heap, varmap, var_escaped);
gcc_assert (VEC_index (varinfo_t, varmap, 3) == var_escaped);
/* Create the NONLOCAL variable, used to represent the set of nonlocal
memory. */
nonlocal_tree = create_tmp_var_raw (ptr_type_node, "NONLOCAL");
var_nonlocal = new_var_info (nonlocal_tree, nonlocal_id, "NONLOCAL");
insert_vi_for_tree (nonlocal_tree, var_nonlocal);
var_nonlocal = new_var_info (NULL_TREE, "NONLOCAL");
gcc_assert (var_nonlocal->id == nonlocal_id);
var_nonlocal->is_artificial_var = 1;
var_nonlocal->offset = 0;
var_nonlocal->size = ~0;
var_nonlocal->fullsize = ~0;
var_nonlocal->is_special_var = 1;
VEC_safe_push (varinfo_t, heap, varmap, var_nonlocal);
/* ESCAPED = *ESCAPED, because escaped is may-deref'd at calls, etc. */
lhs.type = SCALAR;
@ -5203,15 +5160,13 @@ init_base_vars (void)
/* Create the CALLUSED variable, used to represent the set of call-used
memory. */
callused_tree = create_tmp_var_raw (ptr_type_node, "CALLUSED");
var_callused = new_var_info (callused_tree, callused_id, "CALLUSED");
insert_vi_for_tree (callused_tree, var_callused);
var_callused = new_var_info (NULL_TREE, "CALLUSED");
gcc_assert (var_callused->id == callused_id);
var_callused->is_artificial_var = 1;
var_callused->offset = 0;
var_callused->size = ~0;
var_callused->fullsize = ~0;
var_callused->is_special_var = 0;
VEC_safe_push (varinfo_t, heap, varmap, var_callused);
/* CALLUSED = *CALLUSED, because call-used is may-deref'd at calls, etc. */
lhs.type = SCALAR;
@ -5234,29 +5189,24 @@ init_base_vars (void)
/* Create the STOREDANYTHING variable, used to represent the set of
variables stored to *ANYTHING. */
storedanything_tree = create_tmp_var_raw (ptr_type_node, "STOREDANYTHING");
var_storedanything = new_var_info (storedanything_tree, storedanything_id,
"STOREDANYTHING");
insert_vi_for_tree (storedanything_tree, var_storedanything);
var_storedanything = new_var_info (NULL_TREE, "STOREDANYTHING");
gcc_assert (var_storedanything->id == storedanything_id);
var_storedanything->is_artificial_var = 1;
var_storedanything->offset = 0;
var_storedanything->size = ~0;
var_storedanything->fullsize = ~0;
var_storedanything->is_special_var = 0;
VEC_safe_push (varinfo_t, heap, varmap, var_storedanything);
/* Create the INTEGER variable, used to represent that a variable points
to what an INTEGER "points to". */
integer_tree = create_tmp_var_raw (ptr_type_node, "INTEGER");
var_integer = new_var_info (integer_tree, integer_id, "INTEGER");
insert_vi_for_tree (integer_tree, var_integer);
var_integer = new_var_info (NULL_TREE, "INTEGER");
gcc_assert (var_integer->id == integer_id);
var_integer->is_artificial_var = 1;
var_integer->size = ~0;
var_integer->fullsize = ~0;
var_integer->offset = 0;
var_integer->next = NULL;
var_integer->is_special_var = 1;
VEC_safe_push (varinfo_t, heap, varmap, var_integer);
/* INTEGER = ANYTHING, because we don't know where a dereference of
a random integer will point to. */
@ -5446,8 +5396,10 @@ compute_points_to_sets (void)
/* Compute the points-to sets for ESCAPED and CALLUSED used for
call-clobber analysis. */
find_what_var_points_to (var_escaped, &cfun->gimple_df->escaped);
find_what_var_points_to (var_callused, &cfun->gimple_df->callused);
find_what_var_points_to (get_varinfo (escaped_id),
&cfun->gimple_df->escaped);
find_what_var_points_to (get_varinfo (callused_id),
&cfun->gimple_df->callused);
/* Make sure the ESCAPED solution (which is used as placeholder in
other solutions) does not reference itself. This simplifies