[PATCH] Some PTA cleanups
Richard Guenther
rguenther@suse.de
Tue Jun 23 10:52:00 GMT 2009
This simplifies creation of new varinfos and removes the global
trees / varinfos for the artificial variables.
Bootstrapped and tested on x86_64-unknown-linux-gnu, applied to trunk.
Richard.
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.
Index: gcc/tree-ssa-structalias.c
===================================================================
*** gcc/tree-ssa-structalias.c (revision 148785)
--- gcc/tree-ssa-structalias.c (working copy)
*************** struct variable_info
*** 229,234 ****
--- 229,237 ----
/* 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;
*************** enum { nothing_id = 0, anything_id = 1,
*** 284,322 ****
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
--- 287,292 ----
*************** heapvar_insert (tree from, tree to)
*** 350,374 ****
}
/* Return a new variable info structure consisting for a variable
! named NAME, and using constraint graph node NODE. */
static varinfo_t
! new_var_info (tree t, unsigned int id, const char *name)
{
varinfo_t ret = (varinfo_t) pool_alloc (variable_info_pool);
! ret->id = id;
ret->name = name;
ret->decl = t;
! ret->is_artificial_var = false;
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->solution = BITMAP_ALLOC (&pta_obstack);
ret->oldsolution = BITMAP_ALLOC (&oldpta_obstack);
ret->next = NULL;
return ret;
}
--- 320,353 ----
}
/* Return a new variable info structure consisting for a variable
! 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, const char *name)
{
+ unsigned index = VEC_length (varinfo_t, varmap);
varinfo_t ret = (varinfo_t) pool_alloc (variable_info_pool);
! ret->id = index;
ret->name = name;
ret->decl = t;
! /* 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->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;
}
*************** do_ds_constraint (constraint_t c, bitmap
*** 1702,1708 ****
}
}
/* If v is a global variable then this is an escape point. */
! if (is_global_var (v->decl))
{
t = find (escaped_id);
if (add_graph_edge (graph, t, rhs)
--- 1681,1687 ----
}
}
/* If v is a global variable then this is an escape point. */
! if (v->is_global_var)
{
t = find (escaped_id);
if (add_graph_edge (graph, t, rhs)
*************** static struct constraint_expr
*** 2682,2696 ****
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->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;
--- 2661,2673 ----
new_scalar_tmp_constraint_exp (const char *name)
{
struct constraint_expr tmp;
varinfo_t vi;
! vi = new_var_info (NULL_TREE, name);
vi->offset = 0;
vi->size = -1;
vi->fullsize = -1;
vi->is_full_var = 1;
tmp.var = vi->id;
tmp.type = SCALAR;
*************** count_num_arguments (tree decl, bool *is
*** 4263,4269 ****
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;
--- 4240,4245 ----
*************** create_function_info_for (tree decl, con
*** 4271,4282 ****
/* Create the variable info. */
! vi = new_var_info (decl, index, 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++;
--- 4247,4257 ----
/* Create the variable info. */
! 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);
stats.total_vars++;
*************** create_function_info_for (tree decl, con
*** 4287,4296 ****
vi->fullsize = ~0;
vi->size = ~0;
vi->is_unknown_size_var = true;
! return index;
}
-
arg = DECL_ARGUMENTS (decl);
/* Set up variables for each argument. */
--- 4262,4270 ----
vi->fullsize = ~0;
vi->size = ~0;
vi->is_unknown_size_var = true;
! return vi->id;
}
arg = DECL_ARGUMENTS (decl);
/* Set up variables for each argument. */
*************** create_function_info_for (tree decl, con
*** 4299,4317 ****
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->offset = i;
argvi->size = 1;
argvi->is_full_var = true;
--- 4273,4288 ----
varinfo_t argvi;
const char *newname;
char *tempname;
tree argdecl = decl;
if (arg)
argdecl = arg;
asprintf (&tempname, "%s.arg%d", name, i-1);
newname = ggc_strdup (tempname);
free (tempname);
! argvi = new_var_info (argdecl, newname);
argvi->offset = i;
argvi->size = 1;
argvi->is_full_var = true;
*************** create_function_info_for (tree decl, con
*** 4332,4338 ****
varinfo_t resultvi;
const char *newname;
char *tempname;
- unsigned int newindex;
tree resultdecl = decl;
vi->fullsize ++;
--- 4303,4308 ----
*************** create_function_info_for (tree decl, con
*** 4340,4352 ****
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->offset = i;
resultvi->size = 1;
resultvi->fullsize = vi->fullsize;
--- 4310,4320 ----
if (DECL_RESULT (decl))
resultdecl = DECL_RESULT (decl);
asprintf (&tempname, "%s.result", name);
newname = ggc_strdup (tempname);
free (tempname);
! resultvi = new_var_info (resultdecl, newname);
resultvi->offset = i;
resultvi->size = 1;
resultvi->fullsize = vi->fullsize;
*************** create_function_info_for (tree decl, con
*** 4356,4362 ****
if (DECL_RESULT (decl))
insert_vi_for_tree (DECL_RESULT (decl), resultvi);
}
! return index;
}
--- 4324,4331 ----
if (DECL_RESULT (decl))
insert_vi_for_tree (DECL_RESULT (decl), resultvi);
}
!
! return vi->id;
}
*************** check_for_overlaps (VEC (fieldoff_s,heap
*** 4386,4392 ****
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);
--- 4355,4360 ----
*************** create_variable_info_for (tree decl, con
*** 4406,4412 ****
/* 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->offset = 0;
vi->may_have_pointers = could_have_pointers (decl);
if (!declsize
--- 4374,4380 ----
/* 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, name);
vi->offset = 0;
vi->may_have_pointers = could_have_pointers (decl);
if (!declsize
*************** create_variable_info_for (tree decl, con
*** 4423,4429 ****
}
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)
{
--- 4391,4396 ----
*************** create_variable_info_for (tree decl, con
*** 4441,4447 ****
&& 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;
--- 4408,4413 ----
*************** create_variable_info_for (tree decl, con
*** 4481,4487 ****
vi->size = ~0;
vi->is_full_var = true;
VEC_free (fieldoff_s, heap, fieldstack);
! return index;
}
vi->size = fo->size;
--- 4447,4453 ----
vi->size = ~0;
vi->is_full_var = true;
VEC_free (fieldoff_s, heap, fieldstack);
! return vi->id;
}
vi->size = fo->size;
*************** create_variable_info_for (tree decl, con
*** 4495,4501 ****
const char *newname = "NULL";
char *tempname;
- newindex = VEC_length (varinfo_t, varmap);
if (dump_file)
{
asprintf (&tempname, "%s." HOST_WIDE_INT_PRINT_DEC
--- 4461,4466 ----
*************** create_variable_info_for (tree decl, con
*** 4504,4516 ****
newname = ggc_strdup (tempname);
free (tempname);
}
! newvi = new_var_info (decl, newindex, 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);
--- 4469,4480 ----
newname = ggc_strdup (tempname);
free (tempname);
}
! 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);
if (is_global && (!flag_whole_program || !in_ipa_mode)
&& newvi->may_have_pointers)
make_copy_constraint (newvi, nonlocal_id);
*************** create_variable_info_for (tree decl, con
*** 4523,4529 ****
VEC_free (fieldoff_s, heap, fieldstack);
! return index;
}
/* Print out the points-to solution for VAR to FILE. */
--- 4487,4493 ----
VEC_free (fieldoff_s, heap, fieldstack);
! return vi->id;
}
/* Print out the points-to solution for VAR to FILE. */
*************** find_what_var_points_to (varinfo_t vi, s
*** 4770,4776 ****
bitmap_iterator bi;
bitmap finished_solution;
bitmap result;
- tree ptr = vi->decl;
memset (pt, 0, sizeof (struct pt_solution));
--- 4734,4739 ----
*************** find_what_var_points_to (varinfo_t vi, s
*** 4813,4821 ****
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)
--- 4776,4781 ----
*************** static void
*** 5066,5089 ****
init_base_vars (void)
{
struct constraint_expr lhs, rhs;
/* 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->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->is_artificial_var = 1;
var_anything->size = ~0;
var_anything->offset = 0;
--- 5026,5054 ----
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. */
! 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;
/* Create the ANYTHING variable, used to represent that a variable
points to some unknown piece of memory. */
! 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;
*************** init_base_vars (void)
*** 5094,5100 ****
/* 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;
--- 5059,5064 ----
*************** init_base_vars (void)
*** 5109,5124 ****
/* 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->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
--- 5073,5086 ----
/* Create the READONLY variable, used to represent that a variable
points to readonly memory. */
! 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;
/* readonly memory points to anything, in order to make deref
easier. In reality, it points to anything the particular
*************** init_base_vars (void)
*** 5134,5161 ****
/* 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->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->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;
--- 5096,5118 ----
/* Create the ESCAPED variable, used to represent the set of escaped
memory. */
! 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;
/* Create the NONLOCAL variable, used to represent the set of nonlocal
memory. */
! 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;
/* ESCAPED = *ESCAPED, because escaped is may-deref'd at calls, etc. */
lhs.type = SCALAR;
*************** init_base_vars (void)
*** 5203,5217 ****
/* 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->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;
--- 5160,5172 ----
/* Create the CALLUSED variable, used to represent the set of call-used
memory. */
! 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;
/* CALLUSED = *CALLUSED, because call-used is may-deref'd at calls, etc. */
lhs.type = SCALAR;
*************** init_base_vars (void)
*** 5234,5262 ****
/* 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->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->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. */
--- 5189,5212 ----
/* Create the STOREDANYTHING variable, used to represent the set of
variables stored to *ANYTHING. */
! 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;
/* Create the INTEGER variable, used to represent that a variable points
to what an INTEGER "points to". */
! 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;
/* INTEGER = ANYTHING, because we don't know where a dereference of
a random integer will point to. */
*************** compute_points_to_sets (void)
*** 5446,5453 ****
/* 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);
/* Make sure the ESCAPED solution (which is used as placeholder in
other solutions) does not reference itself. This simplifies
--- 5396,5405 ----
/* Compute the points-to sets for ESCAPED and CALLUSED used for
call-clobber analysis. */
! 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
More information about the Gcc-patches
mailing list