/* Tree based points-to analysis
|
/* Tree based points-to analysis
|
Copyright (C) 2005, 2006 Free Software Foundation, Inc.
|
Copyright (C) 2005, 2006 Free Software Foundation, Inc.
|
Contributed by Daniel Berlin <dberlin@dberlin.org>
|
Contributed by Daniel Berlin <dberlin@dberlin.org>
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify
|
GCC is free software; you can redistribute it and/or modify
|
under the terms of the GNU General Public License as published by
|
under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3 of the License, or
|
the Free Software Foundation; either version 3 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
GCC is distributed in the hope that it will be useful,
|
GCC is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "ggc.h"
|
#include "ggc.h"
|
#include "obstack.h"
|
#include "obstack.h"
|
#include "bitmap.h"
|
#include "bitmap.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "hard-reg-set.h"
|
#include "hard-reg-set.h"
|
#include "basic-block.h"
|
#include "basic-block.h"
|
#include "output.h"
|
#include "output.h"
|
#include "errors.h"
|
#include "errors.h"
|
#include "diagnostic.h"
|
#include "diagnostic.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "c-common.h"
|
#include "c-common.h"
|
#include "tree-flow.h"
|
#include "tree-flow.h"
|
#include "tree-inline.h"
|
#include "tree-inline.h"
|
#include "varray.h"
|
#include "varray.h"
|
#include "c-tree.h"
|
#include "c-tree.h"
|
#include "tree-gimple.h"
|
#include "tree-gimple.h"
|
#include "hashtab.h"
|
#include "hashtab.h"
|
#include "function.h"
|
#include "function.h"
|
#include "cgraph.h"
|
#include "cgraph.h"
|
#include "tree-pass.h"
|
#include "tree-pass.h"
|
#include "timevar.h"
|
#include "timevar.h"
|
#include "alloc-pool.h"
|
#include "alloc-pool.h"
|
#include "splay-tree.h"
|
#include "splay-tree.h"
|
#include "params.h"
|
#include "params.h"
|
#include "tree-ssa-structalias.h"
|
#include "tree-ssa-structalias.h"
|
#include "cgraph.h"
|
#include "cgraph.h"
|
#include "pointer-set.h"
|
#include "pointer-set.h"
|
|
|
/* The idea behind this analyzer is to generate set constraints from the
|
/* The idea behind this analyzer is to generate set constraints from the
|
program, then solve the resulting constraints in order to generate the
|
program, then solve the resulting constraints in order to generate the
|
points-to sets.
|
points-to sets.
|
|
|
Set constraints are a way of modeling program analysis problems that
|
Set constraints are a way of modeling program analysis problems that
|
involve sets. They consist of an inclusion constraint language,
|
involve sets. They consist of an inclusion constraint language,
|
describing the variables (each variable is a set) and operations that
|
describing the variables (each variable is a set) and operations that
|
are involved on the variables, and a set of rules that derive facts
|
are involved on the variables, and a set of rules that derive facts
|
from these operations. To solve a system of set constraints, you derive
|
from these operations. To solve a system of set constraints, you derive
|
all possible facts under the rules, which gives you the correct sets
|
all possible facts under the rules, which gives you the correct sets
|
as a consequence.
|
as a consequence.
|
|
|
See "Efficient Field-sensitive pointer analysis for C" by "David
|
See "Efficient Field-sensitive pointer analysis for C" by "David
|
J. Pearce and Paul H. J. Kelly and Chris Hankin, at
|
J. Pearce and Paul H. J. Kelly and Chris Hankin, at
|
http://citeseer.ist.psu.edu/pearce04efficient.html
|
http://citeseer.ist.psu.edu/pearce04efficient.html
|
|
|
Also see "Ultra-fast Aliasing Analysis using CLA: A Million Lines
|
Also see "Ultra-fast Aliasing Analysis using CLA: A Million Lines
|
of C Code in a Second" by ""Nevin Heintze and Olivier Tardieu" at
|
of C Code in a Second" by ""Nevin Heintze and Olivier Tardieu" at
|
http://citeseer.ist.psu.edu/heintze01ultrafast.html
|
http://citeseer.ist.psu.edu/heintze01ultrafast.html
|
|
|
There are three types of real constraint expressions, DEREF,
|
There are three types of real constraint expressions, DEREF,
|
ADDRESSOF, and SCALAR. Each constraint expression consists
|
ADDRESSOF, and SCALAR. Each constraint expression consists
|
of a constraint type, a variable, and an offset.
|
of a constraint type, a variable, and an offset.
|
|
|
SCALAR is a constraint expression type used to represent x, whether
|
SCALAR is a constraint expression type used to represent x, whether
|
it appears on the LHS or the RHS of a statement.
|
it appears on the LHS or the RHS of a statement.
|
DEREF is a constraint expression type used to represent *x, whether
|
DEREF is a constraint expression type used to represent *x, whether
|
it appears on the LHS or the RHS of a statement.
|
it appears on the LHS or the RHS of a statement.
|
ADDRESSOF is a constraint expression used to represent &x, whether
|
ADDRESSOF is a constraint expression used to represent &x, whether
|
it appears on the LHS or the RHS of a statement.
|
it appears on the LHS or the RHS of a statement.
|
|
|
Each pointer variable in the program is assigned an integer id, and
|
Each pointer variable in the program is assigned an integer id, and
|
each field of a structure variable is assigned an integer id as well.
|
each field of a structure variable is assigned an integer id as well.
|
|
|
Structure variables are linked to their list of fields through a "next
|
Structure variables are linked to their list of fields through a "next
|
field" in each variable that points to the next field in offset
|
field" in each variable that points to the next field in offset
|
order.
|
order.
|
Each variable for a structure field has
|
Each variable for a structure field has
|
|
|
1. "size", that tells the size in bits of that field.
|
1. "size", that tells the size in bits of that field.
|
2. "fullsize, that tells the size in bits of the entire structure.
|
2. "fullsize, that tells the size in bits of the entire structure.
|
3. "offset", that tells the offset in bits from the beginning of the
|
3. "offset", that tells the offset in bits from the beginning of the
|
structure to this field.
|
structure to this field.
|
|
|
Thus,
|
Thus,
|
struct f
|
struct f
|
{
|
{
|
int a;
|
int a;
|
int b;
|
int b;
|
} foo;
|
} foo;
|
int *bar;
|
int *bar;
|
|
|
looks like
|
looks like
|
|
|
foo.a -> id 1, size 32, offset 0, fullsize 64, next foo.b
|
foo.a -> id 1, size 32, offset 0, fullsize 64, next foo.b
|
foo.b -> id 2, size 32, offset 32, fullsize 64, next NULL
|
foo.b -> id 2, size 32, offset 32, fullsize 64, next NULL
|
bar -> id 3, size 32, offset 0, fullsize 32, next NULL
|
bar -> id 3, size 32, offset 0, fullsize 32, next NULL
|
|
|
|
|
In order to solve the system of set constraints, the following is
|
In order to solve the system of set constraints, the following is
|
done:
|
done:
|
|
|
1. Each constraint variable x has a solution set associated with it,
|
1. Each constraint variable x has a solution set associated with it,
|
Sol(x).
|
Sol(x).
|
|
|
2. Constraints are separated into direct, copy, and complex.
|
2. Constraints are separated into direct, copy, and complex.
|
Direct constraints are ADDRESSOF constraints that require no extra
|
Direct constraints are ADDRESSOF constraints that require no extra
|
processing, such as P = &Q
|
processing, such as P = &Q
|
Copy constraints are those of the form P = Q.
|
Copy constraints are those of the form P = Q.
|
Complex constraints are all the constraints involving dereferences
|
Complex constraints are all the constraints involving dereferences
|
and offsets (including offsetted copies).
|
and offsets (including offsetted copies).
|
|
|
3. All direct constraints of the form P = &Q are processed, such
|
3. All direct constraints of the form P = &Q are processed, such
|
that Q is added to Sol(P)
|
that Q is added to Sol(P)
|
|
|
4. All complex constraints for a given constraint variable are stored in a
|
4. All complex constraints for a given constraint variable are stored in a
|
linked list attached to that variable's node.
|
linked list attached to that variable's node.
|
|
|
5. A directed graph is built out of the copy constraints. Each
|
5. A directed graph is built out of the copy constraints. Each
|
constraint variable is a node in the graph, and an edge from
|
constraint variable is a node in the graph, and an edge from
|
Q to P is added for each copy constraint of the form P = Q
|
Q to P is added for each copy constraint of the form P = Q
|
|
|
6. The graph is then walked, and solution sets are
|
6. The graph is then walked, and solution sets are
|
propagated along the copy edges, such that an edge from Q to P
|
propagated along the copy edges, such that an edge from Q to P
|
causes Sol(P) <- Sol(P) union Sol(Q).
|
causes Sol(P) <- Sol(P) union Sol(Q).
|
|
|
7. As we visit each node, all complex constraints associated with
|
7. As we visit each node, all complex constraints associated with
|
that node are processed by adding appropriate copy edges to the graph, or the
|
that node are processed by adding appropriate copy edges to the graph, or the
|
appropriate variables to the solution set.
|
appropriate variables to the solution set.
|
|
|
8. The process of walking the graph is iterated until no solution
|
8. The process of walking the graph is iterated until no solution
|
sets change.
|
sets change.
|
|
|
Prior to walking the graph in steps 6 and 7, We perform static
|
Prior to walking the graph in steps 6 and 7, We perform static
|
cycle elimination on the constraint graph, as well
|
cycle elimination on the constraint graph, as well
|
as off-line variable substitution.
|
as off-line variable substitution.
|
|
|
TODO: Adding offsets to pointer-to-structures can be handled (IE not punted
|
TODO: Adding offsets to pointer-to-structures can be handled (IE not punted
|
on and turned into anything), but isn't. You can just see what offset
|
on and turned into anything), but isn't. You can just see what offset
|
inside the pointed-to struct it's going to access.
|
inside the pointed-to struct it's going to access.
|
|
|
TODO: Constant bounded arrays can be handled as if they were structs of the
|
TODO: Constant bounded arrays can be handled as if they were structs of the
|
same number of elements.
|
same number of elements.
|
|
|
TODO: Modeling heap and incoming pointers becomes much better if we
|
TODO: Modeling heap and incoming pointers becomes much better if we
|
add fields to them as we discover them, which we could do.
|
add fields to them as we discover them, which we could do.
|
|
|
TODO: We could handle unions, but to be honest, it's probably not
|
TODO: We could handle unions, but to be honest, it's probably not
|
worth the pain or slowdown. */
|
worth the pain or slowdown. */
|
|
|
static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map))) htab_t heapvar_for_stmt;
|
static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map))) htab_t heapvar_for_stmt;
|
|
|
/* One variable to represent all non-local accesses. */
|
/* One variable to represent all non-local accesses. */
|
tree nonlocal_all;
|
tree nonlocal_all;
|
|
|
static bool use_field_sensitive = true;
|
static bool use_field_sensitive = true;
|
static int in_ipa_mode = 0;
|
static int in_ipa_mode = 0;
|
|
|
/* Used for predecessor bitmaps. */
|
/* Used for predecessor bitmaps. */
|
static bitmap_obstack predbitmap_obstack;
|
static bitmap_obstack predbitmap_obstack;
|
|
|
/* Used for points-to sets. */
|
/* Used for points-to sets. */
|
static bitmap_obstack pta_obstack;
|
static bitmap_obstack pta_obstack;
|
|
|
/* Used for oldsolution members of variables. */
|
/* Used for oldsolution members of variables. */
|
static bitmap_obstack oldpta_obstack;
|
static bitmap_obstack oldpta_obstack;
|
|
|
/* Used for per-solver-iteration bitmaps. */
|
/* Used for per-solver-iteration bitmaps. */
|
static bitmap_obstack iteration_obstack;
|
static bitmap_obstack iteration_obstack;
|
|
|
static unsigned int create_variable_info_for (tree, const char *);
|
static unsigned int create_variable_info_for (tree, const char *);
|
typedef struct constraint_graph *constraint_graph_t;
|
typedef struct constraint_graph *constraint_graph_t;
|
static void unify_nodes (constraint_graph_t, unsigned int, unsigned int, bool);
|
static void unify_nodes (constraint_graph_t, unsigned int, unsigned int, bool);
|
|
|
DEF_VEC_P(constraint_t);
|
DEF_VEC_P(constraint_t);
|
DEF_VEC_ALLOC_P(constraint_t,heap);
|
DEF_VEC_ALLOC_P(constraint_t,heap);
|
|
|
#define EXECUTE_IF_IN_NONNULL_BITMAP(a, b, c, d) \
|
#define EXECUTE_IF_IN_NONNULL_BITMAP(a, b, c, d) \
|
if (a) \
|
if (a) \
|
EXECUTE_IF_SET_IN_BITMAP (a, b, c, d)
|
EXECUTE_IF_SET_IN_BITMAP (a, b, c, d)
|
|
|
static struct constraint_stats
|
static struct constraint_stats
|
{
|
{
|
unsigned int total_vars;
|
unsigned int total_vars;
|
unsigned int nonpointer_vars;
|
unsigned int nonpointer_vars;
|
unsigned int unified_vars_static;
|
unsigned int unified_vars_static;
|
unsigned int unified_vars_dynamic;
|
unsigned int unified_vars_dynamic;
|
unsigned int iterations;
|
unsigned int iterations;
|
unsigned int num_edges;
|
unsigned int num_edges;
|
unsigned int num_implicit_edges;
|
unsigned int num_implicit_edges;
|
unsigned int points_to_sets_created;
|
unsigned int points_to_sets_created;
|
} stats;
|
} stats;
|
|
|
struct variable_info
|
struct variable_info
|
{
|
{
|
/* ID of this variable */
|
/* ID of this variable */
|
unsigned int id;
|
unsigned int id;
|
|
|
/* Name of this variable */
|
/* Name of this variable */
|
const char *name;
|
const char *name;
|
|
|
/* Tree that this variable is associated with. */
|
/* Tree that this variable is associated with. */
|
tree decl;
|
tree decl;
|
|
|
/* Offset of this variable, in bits, from the base variable */
|
/* Offset of this variable, in bits, from the base variable */
|
unsigned HOST_WIDE_INT offset;
|
unsigned HOST_WIDE_INT offset;
|
|
|
/* Size of the variable, in bits. */
|
/* Size of the variable, in bits. */
|
unsigned HOST_WIDE_INT size;
|
unsigned HOST_WIDE_INT size;
|
|
|
/* Full size of the base variable, in bits. */
|
/* Full size of the base variable, in bits. */
|
unsigned HOST_WIDE_INT fullsize;
|
unsigned HOST_WIDE_INT fullsize;
|
|
|
/* A link to the variable for the next field in this structure. */
|
/* A link to the variable for the next field in this structure. */
|
struct variable_info *next;
|
struct variable_info *next;
|
|
|
/* True if the variable is directly the target of a dereference.
|
/* True if the variable is directly the target of a dereference.
|
This is used to track which variables are *actually* dereferenced
|
This is used to track which variables are *actually* dereferenced
|
so we can prune their points to listed. */
|
so we can prune their points to listed. */
|
unsigned int directly_dereferenced:1;
|
unsigned int directly_dereferenced:1;
|
|
|
/* True if this is a variable created by the constraint analysis, such as
|
/* True if this is a variable created by the constraint analysis, such as
|
heap variables and constraints we had to break up. */
|
heap variables and constraints we had to break up. */
|
unsigned int is_artificial_var:1;
|
unsigned int is_artificial_var:1;
|
|
|
/* True if this is a special variable whose solution set should not be
|
/* True if this is a special variable whose solution set should not be
|
changed. */
|
changed. */
|
unsigned int is_special_var:1;
|
unsigned int is_special_var:1;
|
|
|
/* True for variables whose size is not known or variable. */
|
/* True for variables whose size is not known or variable. */
|
unsigned int is_unknown_size_var:1;
|
unsigned int is_unknown_size_var:1;
|
|
|
/* True for variables that have unions somewhere in them. */
|
/* True for variables that have unions somewhere in them. */
|
unsigned int has_union:1;
|
unsigned int has_union:1;
|
|
|
/* True if this is a heap variable. */
|
/* True if this is a heap variable. */
|
unsigned int is_heap_var:1;
|
unsigned int is_heap_var:1;
|
|
|
/* Points-to set for this variable. */
|
/* Points-to set for this variable. */
|
bitmap solution;
|
bitmap solution;
|
|
|
/* Old points-to set for this variable. */
|
/* Old points-to set for this variable. */
|
bitmap oldsolution;
|
bitmap oldsolution;
|
|
|
/* Variable ids represented by this node. */
|
/* Variable ids represented by this node. */
|
bitmap variables;
|
bitmap variables;
|
|
|
/* Variable id this was collapsed to due to type unsafety. This
|
/* Variable id this was collapsed to due to type unsafety. This
|
should be unused completely after build_succ_graph, or something
|
should be unused completely after build_succ_graph, or something
|
is broken. */
|
is broken. */
|
struct variable_info *collapsed_to;
|
struct variable_info *collapsed_to;
|
};
|
};
|
typedef struct variable_info *varinfo_t;
|
typedef struct variable_info *varinfo_t;
|
|
|
static varinfo_t first_vi_for_offset (varinfo_t, unsigned HOST_WIDE_INT);
|
static varinfo_t first_vi_for_offset (varinfo_t, unsigned HOST_WIDE_INT);
|
|
|
/* Pool of variable info structures. */
|
/* Pool of variable info structures. */
|
static alloc_pool variable_info_pool;
|
static alloc_pool variable_info_pool;
|
|
|
DEF_VEC_P(varinfo_t);
|
DEF_VEC_P(varinfo_t);
|
|
|
DEF_VEC_ALLOC_P(varinfo_t, heap);
|
DEF_VEC_ALLOC_P(varinfo_t, heap);
|
|
|
/* Table of variable info structures for constraint variables.
|
/* Table of variable info structures for constraint variables.
|
Indexed directly by variable info id. */
|
Indexed directly by variable info id. */
|
static VEC(varinfo_t,heap) *varmap;
|
static VEC(varinfo_t,heap) *varmap;
|
|
|
/* Return the varmap element N */
|
/* Return the varmap element N */
|
|
|
static inline varinfo_t
|
static inline varinfo_t
|
get_varinfo (unsigned int n)
|
get_varinfo (unsigned int n)
|
{
|
{
|
return VEC_index (varinfo_t, varmap, n);
|
return VEC_index (varinfo_t, varmap, n);
|
}
|
}
|
|
|
/* Return the varmap element N, following the collapsed_to link. */
|
/* Return the varmap element N, following the collapsed_to link. */
|
|
|
static inline varinfo_t
|
static inline varinfo_t
|
get_varinfo_fc (unsigned int n)
|
get_varinfo_fc (unsigned int n)
|
{
|
{
|
varinfo_t v = VEC_index (varinfo_t, varmap, n);
|
varinfo_t v = VEC_index (varinfo_t, varmap, n);
|
|
|
if (v->collapsed_to)
|
if (v->collapsed_to)
|
return v->collapsed_to;
|
return v->collapsed_to;
|
return v;
|
return v;
|
}
|
}
|
|
|
/* Variable that represents the unknown pointer. */
|
/* Variable that represents the unknown pointer. */
|
static varinfo_t var_anything;
|
static varinfo_t var_anything;
|
static tree anything_tree;
|
static tree anything_tree;
|
static unsigned int anything_id;
|
static unsigned int anything_id;
|
|
|
/* Variable that represents the NULL pointer. */
|
/* Variable that represents the NULL pointer. */
|
static varinfo_t var_nothing;
|
static varinfo_t var_nothing;
|
static tree nothing_tree;
|
static tree nothing_tree;
|
static unsigned int nothing_id;
|
static unsigned int nothing_id;
|
|
|
/* Variable that represents read only memory. */
|
/* Variable that represents read only memory. */
|
static varinfo_t var_readonly;
|
static varinfo_t var_readonly;
|
static tree readonly_tree;
|
static tree readonly_tree;
|
static unsigned int readonly_id;
|
static unsigned int readonly_id;
|
|
|
/* Variable that represents integers. This is used for when people do things
|
/* Variable that represents integers. This is used for when people do things
|
like &0->a.b. */
|
like &0->a.b. */
|
static varinfo_t var_integer;
|
static varinfo_t var_integer;
|
static tree integer_tree;
|
static tree integer_tree;
|
static unsigned int integer_id;
|
static unsigned int integer_id;
|
|
|
/* Variable that represents escaped variables. This is used to give
|
/* Variable that represents escaped variables. This is used to give
|
incoming pointer variables a better set than ANYTHING. */
|
incoming pointer variables a better set than ANYTHING. */
|
static varinfo_t var_escaped_vars;
|
static varinfo_t var_escaped_vars;
|
static tree escaped_vars_tree;
|
static tree escaped_vars_tree;
|
static unsigned int escaped_vars_id;
|
static unsigned int escaped_vars_id;
|
|
|
/* Variable that represents non-local variables before we expand it to
|
/* Variable that represents non-local variables before we expand it to
|
one for each type. */
|
one for each type. */
|
static unsigned int nonlocal_vars_id;
|
static unsigned int nonlocal_vars_id;
|
/* Lookup a heap var for FROM, and return it if we find one. */
|
/* Lookup a heap var for FROM, and return it if we find one. */
|
|
|
static tree
|
static tree
|
heapvar_lookup (tree from)
|
heapvar_lookup (tree from)
|
{
|
{
|
struct tree_map *h, in;
|
struct tree_map *h, in;
|
in.from = from;
|
in.from = from;
|
|
|
h = htab_find_with_hash (heapvar_for_stmt, &in, htab_hash_pointer (from));
|
h = htab_find_with_hash (heapvar_for_stmt, &in, htab_hash_pointer (from));
|
if (h)
|
if (h)
|
return h->to;
|
return h->to;
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Insert a mapping FROM->TO in the heap var for statement
|
/* Insert a mapping FROM->TO in the heap var for statement
|
hashtable. */
|
hashtable. */
|
|
|
static void
|
static void
|
heapvar_insert (tree from, tree to)
|
heapvar_insert (tree from, tree to)
|
{
|
{
|
struct tree_map *h;
|
struct tree_map *h;
|
void **loc;
|
void **loc;
|
|
|
h = ggc_alloc (sizeof (struct tree_map));
|
h = ggc_alloc (sizeof (struct tree_map));
|
h->hash = htab_hash_pointer (from);
|
h->hash = htab_hash_pointer (from);
|
h->from = from;
|
h->from = from;
|
h->to = to;
|
h->to = to;
|
loc = htab_find_slot_with_hash (heapvar_for_stmt, h, h->hash, INSERT);
|
loc = htab_find_slot_with_hash (heapvar_for_stmt, h, h->hash, INSERT);
|
*(struct tree_map **) loc = h;
|
*(struct tree_map **) loc = h;
|
}
|
}
|
|
|
/* Return a new variable info structure consisting for a variable
|
/* 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. */
|
|
|
static varinfo_t
|
static varinfo_t
|
new_var_info (tree t, unsigned int id, const char *name)
|
new_var_info (tree t, unsigned int id, const char *name)
|
{
|
{
|
varinfo_t ret = pool_alloc (variable_info_pool);
|
varinfo_t ret = pool_alloc (variable_info_pool);
|
|
|
ret->id = id;
|
ret->id = id;
|
ret->name = name;
|
ret->name = name;
|
ret->decl = t;
|
ret->decl = t;
|
ret->directly_dereferenced = false;
|
ret->directly_dereferenced = false;
|
ret->is_artificial_var = false;
|
ret->is_artificial_var = false;
|
ret->is_heap_var = false;
|
ret->is_heap_var = false;
|
ret->is_special_var = false;
|
ret->is_special_var = false;
|
ret->is_unknown_size_var = false;
|
ret->is_unknown_size_var = false;
|
ret->has_union = false;
|
ret->has_union = false;
|
ret->solution = BITMAP_ALLOC (&pta_obstack);
|
ret->solution = BITMAP_ALLOC (&pta_obstack);
|
ret->oldsolution = BITMAP_ALLOC (&oldpta_obstack);
|
ret->oldsolution = BITMAP_ALLOC (&oldpta_obstack);
|
ret->next = NULL;
|
ret->next = NULL;
|
ret->collapsed_to = NULL;
|
ret->collapsed_to = NULL;
|
return ret;
|
return ret;
|
}
|
}
|
|
|
typedef enum {SCALAR, DEREF, ADDRESSOF} constraint_expr_type;
|
typedef enum {SCALAR, DEREF, ADDRESSOF} constraint_expr_type;
|
|
|
/* An expression that appears in a constraint. */
|
/* An expression that appears in a constraint. */
|
|
|
struct constraint_expr
|
struct constraint_expr
|
{
|
{
|
/* Constraint type. */
|
/* Constraint type. */
|
constraint_expr_type type;
|
constraint_expr_type type;
|
|
|
/* Variable we are referring to in the constraint. */
|
/* Variable we are referring to in the constraint. */
|
unsigned int var;
|
unsigned int var;
|
|
|
/* Offset, in bits, of this constraint from the beginning of
|
/* Offset, in bits, of this constraint from the beginning of
|
variables it ends up referring to.
|
variables it ends up referring to.
|
|
|
IOW, in a deref constraint, we would deref, get the result set,
|
IOW, in a deref constraint, we would deref, get the result set,
|
then add OFFSET to each member. */
|
then add OFFSET to each member. */
|
unsigned HOST_WIDE_INT offset;
|
unsigned HOST_WIDE_INT offset;
|
};
|
};
|
|
|
typedef struct constraint_expr ce_s;
|
typedef struct constraint_expr ce_s;
|
DEF_VEC_O(ce_s);
|
DEF_VEC_O(ce_s);
|
DEF_VEC_ALLOC_O(ce_s, heap);
|
DEF_VEC_ALLOC_O(ce_s, heap);
|
static void get_constraint_for (tree, VEC(ce_s, heap) **);
|
static void get_constraint_for (tree, VEC(ce_s, heap) **);
|
static void do_deref (VEC (ce_s, heap) **);
|
static void do_deref (VEC (ce_s, heap) **);
|
|
|
/* Our set constraints are made up of two constraint expressions, one
|
/* Our set constraints are made up of two constraint expressions, one
|
LHS, and one RHS.
|
LHS, and one RHS.
|
|
|
As described in the introduction, our set constraints each represent an
|
As described in the introduction, our set constraints each represent an
|
operation between set valued variables.
|
operation between set valued variables.
|
*/
|
*/
|
struct constraint
|
struct constraint
|
{
|
{
|
struct constraint_expr lhs;
|
struct constraint_expr lhs;
|
struct constraint_expr rhs;
|
struct constraint_expr rhs;
|
};
|
};
|
|
|
/* List of constraints that we use to build the constraint graph from. */
|
/* List of constraints that we use to build the constraint graph from. */
|
|
|
static VEC(constraint_t,heap) *constraints;
|
static VEC(constraint_t,heap) *constraints;
|
static alloc_pool constraint_pool;
|
static alloc_pool constraint_pool;
|
|
|
|
|
DEF_VEC_I(int);
|
DEF_VEC_I(int);
|
DEF_VEC_ALLOC_I(int, heap);
|
DEF_VEC_ALLOC_I(int, heap);
|
|
|
/* The constraint graph is represented as an array of bitmaps
|
/* The constraint graph is represented as an array of bitmaps
|
containing successor nodes. */
|
containing successor nodes. */
|
|
|
struct constraint_graph
|
struct constraint_graph
|
{
|
{
|
/* Size of this graph, which may be different than the number of
|
/* Size of this graph, which may be different than the number of
|
nodes in the variable map. */
|
nodes in the variable map. */
|
unsigned int size;
|
unsigned int size;
|
|
|
/* Explicit successors of each node. */
|
/* Explicit successors of each node. */
|
bitmap *succs;
|
bitmap *succs;
|
|
|
/* Implicit predecessors of each node (Used for variable
|
/* Implicit predecessors of each node (Used for variable
|
substitution). */
|
substitution). */
|
bitmap *implicit_preds;
|
bitmap *implicit_preds;
|
|
|
/* Explicit predecessors of each node (Used for variable substitution). */
|
/* Explicit predecessors of each node (Used for variable substitution). */
|
bitmap *preds;
|
bitmap *preds;
|
|
|
/* Indirect cycle representatives, or -1 if the node has no indirect
|
/* Indirect cycle representatives, or -1 if the node has no indirect
|
cycles. */
|
cycles. */
|
int *indirect_cycles;
|
int *indirect_cycles;
|
|
|
/* Representative node for a node. rep[a] == a unless the node has
|
/* Representative node for a node. rep[a] == a unless the node has
|
been unified. */
|
been unified. */
|
unsigned int *rep;
|
unsigned int *rep;
|
|
|
/* Equivalence class representative for a node. This is used for
|
/* Equivalence class representative for a node. This is used for
|
variable substitution. */
|
variable substitution. */
|
int *eq_rep;
|
int *eq_rep;
|
|
|
/* Label for each node, used during variable substitution. */
|
/* Label for each node, used during variable substitution. */
|
unsigned int *label;
|
unsigned int *label;
|
|
|
/* Bitmap of nodes where the bit is set if the node is a direct
|
/* Bitmap of nodes where the bit is set if the node is a direct
|
node. Used for variable substitution. */
|
node. Used for variable substitution. */
|
sbitmap direct_nodes;
|
sbitmap direct_nodes;
|
|
|
/* Vector of complex constraints for each graph node. Complex
|
/* Vector of complex constraints for each graph node. Complex
|
constraints are those involving dereferences or offsets that are
|
constraints are those involving dereferences or offsets that are
|
not 0. */
|
not 0. */
|
VEC(constraint_t,heap) **complex;
|
VEC(constraint_t,heap) **complex;
|
};
|
};
|
|
|
static constraint_graph_t graph;
|
static constraint_graph_t graph;
|
|
|
/* During variable substitution and the offline version of indirect
|
/* During variable substitution and the offline version of indirect
|
cycle finding, we create nodes to represent dereferences and
|
cycle finding, we create nodes to represent dereferences and
|
address taken constraints. These represent where these start and
|
address taken constraints. These represent where these start and
|
end. */
|
end. */
|
#define FIRST_REF_NODE (VEC_length (varinfo_t, varmap))
|
#define FIRST_REF_NODE (VEC_length (varinfo_t, varmap))
|
#define LAST_REF_NODE (FIRST_REF_NODE + (FIRST_REF_NODE - 1))
|
#define LAST_REF_NODE (FIRST_REF_NODE + (FIRST_REF_NODE - 1))
|
#define FIRST_ADDR_NODE (LAST_REF_NODE + 1)
|
#define FIRST_ADDR_NODE (LAST_REF_NODE + 1)
|
|
|
/* Return the representative node for NODE, if NODE has been unioned
|
/* Return the representative node for NODE, if NODE has been unioned
|
with another NODE.
|
with another NODE.
|
This function performs path compression along the way to finding
|
This function performs path compression along the way to finding
|
the representative. */
|
the representative. */
|
|
|
static unsigned int
|
static unsigned int
|
find (unsigned int node)
|
find (unsigned int node)
|
{
|
{
|
gcc_assert (node < graph->size);
|
gcc_assert (node < graph->size);
|
if (graph->rep[node] != node)
|
if (graph->rep[node] != node)
|
return graph->rep[node] = find (graph->rep[node]);
|
return graph->rep[node] = find (graph->rep[node]);
|
return node;
|
return node;
|
}
|
}
|
|
|
/* Union the TO and FROM nodes to the TO nodes.
|
/* Union the TO and FROM nodes to the TO nodes.
|
Note that at some point in the future, we may want to do
|
Note that at some point in the future, we may want to do
|
union-by-rank, in which case we are going to have to return the
|
union-by-rank, in which case we are going to have to return the
|
node we unified to. */
|
node we unified to. */
|
|
|
static bool
|
static bool
|
unite (unsigned int to, unsigned int from)
|
unite (unsigned int to, unsigned int from)
|
{
|
{
|
gcc_assert (to < graph->size && from < graph->size);
|
gcc_assert (to < graph->size && from < graph->size);
|
if (to != from && graph->rep[from] != to)
|
if (to != from && graph->rep[from] != to)
|
{
|
{
|
graph->rep[from] = to;
|
graph->rep[from] = to;
|
return true;
|
return true;
|
}
|
}
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Create a new constraint consisting of LHS and RHS expressions. */
|
/* Create a new constraint consisting of LHS and RHS expressions. */
|
|
|
static constraint_t
|
static constraint_t
|
new_constraint (const struct constraint_expr lhs,
|
new_constraint (const struct constraint_expr lhs,
|
const struct constraint_expr rhs)
|
const struct constraint_expr rhs)
|
{
|
{
|
constraint_t ret = pool_alloc (constraint_pool);
|
constraint_t ret = pool_alloc (constraint_pool);
|
ret->lhs = lhs;
|
ret->lhs = lhs;
|
ret->rhs = rhs;
|
ret->rhs = rhs;
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* Print out constraint C to FILE. */
|
/* Print out constraint C to FILE. */
|
|
|
void
|
void
|
dump_constraint (FILE *file, constraint_t c)
|
dump_constraint (FILE *file, constraint_t c)
|
{
|
{
|
if (c->lhs.type == ADDRESSOF)
|
if (c->lhs.type == ADDRESSOF)
|
fprintf (file, "&");
|
fprintf (file, "&");
|
else if (c->lhs.type == DEREF)
|
else if (c->lhs.type == DEREF)
|
fprintf (file, "*");
|
fprintf (file, "*");
|
fprintf (file, "%s", get_varinfo_fc (c->lhs.var)->name);
|
fprintf (file, "%s", get_varinfo_fc (c->lhs.var)->name);
|
if (c->lhs.offset != 0)
|
if (c->lhs.offset != 0)
|
fprintf (file, " + " HOST_WIDE_INT_PRINT_DEC, c->lhs.offset);
|
fprintf (file, " + " HOST_WIDE_INT_PRINT_DEC, c->lhs.offset);
|
fprintf (file, " = ");
|
fprintf (file, " = ");
|
if (c->rhs.type == ADDRESSOF)
|
if (c->rhs.type == ADDRESSOF)
|
fprintf (file, "&");
|
fprintf (file, "&");
|
else if (c->rhs.type == DEREF)
|
else if (c->rhs.type == DEREF)
|
fprintf (file, "*");
|
fprintf (file, "*");
|
fprintf (file, "%s", get_varinfo_fc (c->rhs.var)->name);
|
fprintf (file, "%s", get_varinfo_fc (c->rhs.var)->name);
|
if (c->rhs.offset != 0)
|
if (c->rhs.offset != 0)
|
fprintf (file, " + " HOST_WIDE_INT_PRINT_DEC, c->rhs.offset);
|
fprintf (file, " + " HOST_WIDE_INT_PRINT_DEC, c->rhs.offset);
|
fprintf (file, "\n");
|
fprintf (file, "\n");
|
}
|
}
|
|
|
/* Print out constraint C to stderr. */
|
/* Print out constraint C to stderr. */
|
|
|
void
|
void
|
debug_constraint (constraint_t c)
|
debug_constraint (constraint_t c)
|
{
|
{
|
dump_constraint (stderr, c);
|
dump_constraint (stderr, c);
|
}
|
}
|
|
|
/* Print out all constraints to FILE */
|
/* Print out all constraints to FILE */
|
|
|
void
|
void
|
dump_constraints (FILE *file)
|
dump_constraints (FILE *file)
|
{
|
{
|
int i;
|
int i;
|
constraint_t c;
|
constraint_t c;
|
for (i = 0; VEC_iterate (constraint_t, constraints, i, c); i++)
|
for (i = 0; VEC_iterate (constraint_t, constraints, i, c); i++)
|
dump_constraint (file, c);
|
dump_constraint (file, c);
|
}
|
}
|
|
|
/* Print out all constraints to stderr. */
|
/* Print out all constraints to stderr. */
|
|
|
void
|
void
|
debug_constraints (void)
|
debug_constraints (void)
|
{
|
{
|
dump_constraints (stderr);
|
dump_constraints (stderr);
|
}
|
}
|
|
|
/* SOLVER FUNCTIONS
|
/* SOLVER FUNCTIONS
|
|
|
The solver is a simple worklist solver, that works on the following
|
The solver is a simple worklist solver, that works on the following
|
algorithm:
|
algorithm:
|
|
|
sbitmap changed_nodes = all zeroes;
|
sbitmap changed_nodes = all zeroes;
|
changed_count = 0;
|
changed_count = 0;
|
For each node that is not already collapsed:
|
For each node that is not already collapsed:
|
changed_count++;
|
changed_count++;
|
set bit in changed nodes
|
set bit in changed nodes
|
|
|
while (changed_count > 0)
|
while (changed_count > 0)
|
{
|
{
|
compute topological ordering for constraint graph
|
compute topological ordering for constraint graph
|
|
|
find and collapse cycles in the constraint graph (updating
|
find and collapse cycles in the constraint graph (updating
|
changed if necessary)
|
changed if necessary)
|
|
|
for each node (n) in the graph in topological order:
|
for each node (n) in the graph in topological order:
|
changed_count--;
|
changed_count--;
|
|
|
Process each complex constraint associated with the node,
|
Process each complex constraint associated with the node,
|
updating changed if necessary.
|
updating changed if necessary.
|
|
|
For each outgoing edge from n, propagate the solution from n to
|
For each outgoing edge from n, propagate the solution from n to
|
the destination of the edge, updating changed as necessary.
|
the destination of the edge, updating changed as necessary.
|
|
|
} */
|
} */
|
|
|
/* Return true if two constraint expressions A and B are equal. */
|
/* Return true if two constraint expressions A and B are equal. */
|
|
|
static bool
|
static bool
|
constraint_expr_equal (struct constraint_expr a, struct constraint_expr b)
|
constraint_expr_equal (struct constraint_expr a, struct constraint_expr b)
|
{
|
{
|
return a.type == b.type && a.var == b.var && a.offset == b.offset;
|
return a.type == b.type && a.var == b.var && a.offset == b.offset;
|
}
|
}
|
|
|
/* Return true if constraint expression A is less than constraint expression
|
/* Return true if constraint expression A is less than constraint expression
|
B. This is just arbitrary, but consistent, in order to give them an
|
B. This is just arbitrary, but consistent, in order to give them an
|
ordering. */
|
ordering. */
|
|
|
static bool
|
static bool
|
constraint_expr_less (struct constraint_expr a, struct constraint_expr b)
|
constraint_expr_less (struct constraint_expr a, struct constraint_expr b)
|
{
|
{
|
if (a.type == b.type)
|
if (a.type == b.type)
|
{
|
{
|
if (a.var == b.var)
|
if (a.var == b.var)
|
return a.offset < b.offset;
|
return a.offset < b.offset;
|
else
|
else
|
return a.var < b.var;
|
return a.var < b.var;
|
}
|
}
|
else
|
else
|
return a.type < b.type;
|
return a.type < b.type;
|
}
|
}
|
|
|
/* Return true if constraint A is less than constraint B. This is just
|
/* Return true if constraint A is less than constraint B. This is just
|
arbitrary, but consistent, in order to give them an ordering. */
|
arbitrary, but consistent, in order to give them an ordering. */
|
|
|
static bool
|
static bool
|
constraint_less (const constraint_t a, const constraint_t b)
|
constraint_less (const constraint_t a, const constraint_t b)
|
{
|
{
|
if (constraint_expr_less (a->lhs, b->lhs))
|
if (constraint_expr_less (a->lhs, b->lhs))
|
return true;
|
return true;
|
else if (constraint_expr_less (b->lhs, a->lhs))
|
else if (constraint_expr_less (b->lhs, a->lhs))
|
return false;
|
return false;
|
else
|
else
|
return constraint_expr_less (a->rhs, b->rhs);
|
return constraint_expr_less (a->rhs, b->rhs);
|
}
|
}
|
|
|
/* Return true if two constraints A and B are equal. */
|
/* Return true if two constraints A and B are equal. */
|
|
|
static bool
|
static bool
|
constraint_equal (struct constraint a, struct constraint b)
|
constraint_equal (struct constraint a, struct constraint b)
|
{
|
{
|
return constraint_expr_equal (a.lhs, b.lhs)
|
return constraint_expr_equal (a.lhs, b.lhs)
|
&& constraint_expr_equal (a.rhs, b.rhs);
|
&& constraint_expr_equal (a.rhs, b.rhs);
|
}
|
}
|
|
|
|
|
/* Find a constraint LOOKFOR in the sorted constraint vector VEC */
|
/* Find a constraint LOOKFOR in the sorted constraint vector VEC */
|
|
|
static constraint_t
|
static constraint_t
|
constraint_vec_find (VEC(constraint_t,heap) *vec,
|
constraint_vec_find (VEC(constraint_t,heap) *vec,
|
struct constraint lookfor)
|
struct constraint lookfor)
|
{
|
{
|
unsigned int place;
|
unsigned int place;
|
constraint_t found;
|
constraint_t found;
|
|
|
if (vec == NULL)
|
if (vec == NULL)
|
return NULL;
|
return NULL;
|
|
|
place = VEC_lower_bound (constraint_t, vec, &lookfor, constraint_less);
|
place = VEC_lower_bound (constraint_t, vec, &lookfor, constraint_less);
|
if (place >= VEC_length (constraint_t, vec))
|
if (place >= VEC_length (constraint_t, vec))
|
return NULL;
|
return NULL;
|
found = VEC_index (constraint_t, vec, place);
|
found = VEC_index (constraint_t, vec, place);
|
if (!constraint_equal (*found, lookfor))
|
if (!constraint_equal (*found, lookfor))
|
return NULL;
|
return NULL;
|
return found;
|
return found;
|
}
|
}
|
|
|
/* Union two constraint vectors, TO and FROM. Put the result in TO. */
|
/* Union two constraint vectors, TO and FROM. Put the result in TO. */
|
|
|
static void
|
static void
|
constraint_set_union (VEC(constraint_t,heap) **to,
|
constraint_set_union (VEC(constraint_t,heap) **to,
|
VEC(constraint_t,heap) **from)
|
VEC(constraint_t,heap) **from)
|
{
|
{
|
int i;
|
int i;
|
constraint_t c;
|
constraint_t c;
|
|
|
for (i = 0; VEC_iterate (constraint_t, *from, i, c); i++)
|
for (i = 0; VEC_iterate (constraint_t, *from, i, c); i++)
|
{
|
{
|
if (constraint_vec_find (*to, *c) == NULL)
|
if (constraint_vec_find (*to, *c) == NULL)
|
{
|
{
|
unsigned int place = VEC_lower_bound (constraint_t, *to, c,
|
unsigned int place = VEC_lower_bound (constraint_t, *to, c,
|
constraint_less);
|
constraint_less);
|
VEC_safe_insert (constraint_t, heap, *to, place, c);
|
VEC_safe_insert (constraint_t, heap, *to, place, c);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Take a solution set SET, add OFFSET to each member of the set, and
|
/* Take a solution set SET, add OFFSET to each member of the set, and
|
overwrite SET with the result when done. */
|
overwrite SET with the result when done. */
|
|
|
static void
|
static void
|
solution_set_add (bitmap set, unsigned HOST_WIDE_INT offset)
|
solution_set_add (bitmap set, unsigned HOST_WIDE_INT offset)
|
{
|
{
|
bitmap result = BITMAP_ALLOC (&iteration_obstack);
|
bitmap result = BITMAP_ALLOC (&iteration_obstack);
|
unsigned int i;
|
unsigned int i;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
unsigned HOST_WIDE_INT min = -1, max = 0;
|
unsigned HOST_WIDE_INT min = -1, max = 0;
|
|
|
/* Compute set of vars we can reach from set + offset. */
|
/* Compute set of vars we can reach from set + offset. */
|
|
|
EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi)
|
EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi)
|
{
|
{
|
if (get_varinfo (i)->is_artificial_var
|
if (get_varinfo (i)->is_artificial_var
|
|| get_varinfo (i)->has_union
|
|| get_varinfo (i)->has_union
|
|| get_varinfo (i)->is_unknown_size_var)
|
|| get_varinfo (i)->is_unknown_size_var)
|
continue;
|
continue;
|
|
|
if (get_varinfo (i)->offset + offset < min)
|
if (get_varinfo (i)->offset + offset < min)
|
min = get_varinfo (i)->offset + offset;
|
min = get_varinfo (i)->offset + offset;
|
if (get_varinfo (i)->offset + get_varinfo (i)->size + offset > max)
|
if (get_varinfo (i)->offset + get_varinfo (i)->size + offset > max)
|
{
|
{
|
max = get_varinfo (i)->offset + get_varinfo (i)->size + offset;
|
max = get_varinfo (i)->offset + get_varinfo (i)->size + offset;
|
if (max > get_varinfo (i)->fullsize)
|
if (max > get_varinfo (i)->fullsize)
|
max = get_varinfo (i)->fullsize;
|
max = get_varinfo (i)->fullsize;
|
}
|
}
|
}
|
}
|
|
|
EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi)
|
EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi)
|
{
|
{
|
/* If this is a properly sized variable, only add offset if it's
|
/* If this is a properly sized variable, only add offset if it's
|
less than end. Otherwise, it is globbed to a single
|
less than end. Otherwise, it is globbed to a single
|
variable. */
|
variable. */
|
|
|
if (get_varinfo (i)->offset + get_varinfo (i)->size - 1 >= min
|
if (get_varinfo (i)->offset + get_varinfo (i)->size - 1 >= min
|
&& get_varinfo (i)->offset < max)
|
&& get_varinfo (i)->offset < max)
|
{
|
{
|
bitmap_set_bit (result, i);
|
bitmap_set_bit (result, i);
|
}
|
}
|
else if (get_varinfo (i)->is_artificial_var
|
else if (get_varinfo (i)->is_artificial_var
|
|| get_varinfo (i)->has_union
|
|| get_varinfo (i)->has_union
|
|| get_varinfo (i)->is_unknown_size_var)
|
|| get_varinfo (i)->is_unknown_size_var)
|
{
|
{
|
bitmap_set_bit (result, i);
|
bitmap_set_bit (result, i);
|
}
|
}
|
}
|
}
|
|
|
bitmap_copy (set, result);
|
bitmap_copy (set, result);
|
BITMAP_FREE (result);
|
BITMAP_FREE (result);
|
}
|
}
|
|
|
/* Union solution sets TO and FROM, and add INC to each member of FROM in the
|
/* Union solution sets TO and FROM, and add INC to each member of FROM in the
|
process. */
|
process. */
|
|
|
static bool
|
static bool
|
set_union_with_increment (bitmap to, bitmap from, unsigned HOST_WIDE_INT inc)
|
set_union_with_increment (bitmap to, bitmap from, unsigned HOST_WIDE_INT inc)
|
{
|
{
|
if (inc == 0)
|
if (inc == 0)
|
return bitmap_ior_into (to, from);
|
return bitmap_ior_into (to, from);
|
else
|
else
|
{
|
{
|
bitmap tmp;
|
bitmap tmp;
|
bool res;
|
bool res;
|
|
|
tmp = BITMAP_ALLOC (&iteration_obstack);
|
tmp = BITMAP_ALLOC (&iteration_obstack);
|
bitmap_copy (tmp, from);
|
bitmap_copy (tmp, from);
|
solution_set_add (tmp, inc);
|
solution_set_add (tmp, inc);
|
res = bitmap_ior_into (to, tmp);
|
res = bitmap_ior_into (to, tmp);
|
BITMAP_FREE (tmp);
|
BITMAP_FREE (tmp);
|
return res;
|
return res;
|
}
|
}
|
}
|
}
|
|
|
/* Insert constraint C into the list of complex constraints for graph
|
/* Insert constraint C into the list of complex constraints for graph
|
node VAR. */
|
node VAR. */
|
|
|
static void
|
static void
|
insert_into_complex (constraint_graph_t graph,
|
insert_into_complex (constraint_graph_t graph,
|
unsigned int var, constraint_t c)
|
unsigned int var, constraint_t c)
|
{
|
{
|
VEC (constraint_t, heap) *complex = graph->complex[var];
|
VEC (constraint_t, heap) *complex = graph->complex[var];
|
unsigned int place = VEC_lower_bound (constraint_t, complex, c,
|
unsigned int place = VEC_lower_bound (constraint_t, complex, c,
|
constraint_less);
|
constraint_less);
|
|
|
/* Only insert constraints that do not already exist. */
|
/* Only insert constraints that do not already exist. */
|
if (place >= VEC_length (constraint_t, complex)
|
if (place >= VEC_length (constraint_t, complex)
|
|| !constraint_equal (*c, *VEC_index (constraint_t, complex, place)))
|
|| !constraint_equal (*c, *VEC_index (constraint_t, complex, place)))
|
VEC_safe_insert (constraint_t, heap, graph->complex[var], place, c);
|
VEC_safe_insert (constraint_t, heap, graph->complex[var], place, c);
|
}
|
}
|
|
|
|
|
/* Condense two variable nodes into a single variable node, by moving
|
/* Condense two variable nodes into a single variable node, by moving
|
all associated info from SRC to TO. */
|
all associated info from SRC to TO. */
|
|
|
static void
|
static void
|
merge_node_constraints (constraint_graph_t graph, unsigned int to,
|
merge_node_constraints (constraint_graph_t graph, unsigned int to,
|
unsigned int from)
|
unsigned int from)
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
constraint_t c;
|
constraint_t c;
|
|
|
gcc_assert (find (from) == to);
|
gcc_assert (find (from) == to);
|
|
|
/* Move all complex constraints from src node into to node */
|
/* Move all complex constraints from src node into to node */
|
for (i = 0; VEC_iterate (constraint_t, graph->complex[from], i, c); i++)
|
for (i = 0; VEC_iterate (constraint_t, graph->complex[from], i, c); i++)
|
{
|
{
|
/* In complex constraints for node src, we may have either
|
/* In complex constraints for node src, we may have either
|
a = *src, and *src = a, or an offseted constraint which are
|
a = *src, and *src = a, or an offseted constraint which are
|
always added to the rhs node's constraints. */
|
always added to the rhs node's constraints. */
|
|
|
if (c->rhs.type == DEREF)
|
if (c->rhs.type == DEREF)
|
c->rhs.var = to;
|
c->rhs.var = to;
|
else if (c->lhs.type == DEREF)
|
else if (c->lhs.type == DEREF)
|
c->lhs.var = to;
|
c->lhs.var = to;
|
else
|
else
|
c->rhs.var = to;
|
c->rhs.var = to;
|
}
|
}
|
constraint_set_union (&graph->complex[to], &graph->complex[from]);
|
constraint_set_union (&graph->complex[to], &graph->complex[from]);
|
VEC_free (constraint_t, heap, graph->complex[from]);
|
VEC_free (constraint_t, heap, graph->complex[from]);
|
graph->complex[from] = NULL;
|
graph->complex[from] = NULL;
|
}
|
}
|
|
|
|
|
/* Remove edges involving NODE from GRAPH. */
|
/* Remove edges involving NODE from GRAPH. */
|
|
|
static void
|
static void
|
clear_edges_for_node (constraint_graph_t graph, unsigned int node)
|
clear_edges_for_node (constraint_graph_t graph, unsigned int node)
|
{
|
{
|
if (graph->succs[node])
|
if (graph->succs[node])
|
BITMAP_FREE (graph->succs[node]);
|
BITMAP_FREE (graph->succs[node]);
|
}
|
}
|
|
|
/* Merge GRAPH nodes FROM and TO into node TO. */
|
/* Merge GRAPH nodes FROM and TO into node TO. */
|
|
|
static void
|
static void
|
merge_graph_nodes (constraint_graph_t graph, unsigned int to,
|
merge_graph_nodes (constraint_graph_t graph, unsigned int to,
|
unsigned int from)
|
unsigned int from)
|
{
|
{
|
if (graph->indirect_cycles[from] != -1)
|
if (graph->indirect_cycles[from] != -1)
|
{
|
{
|
/* If we have indirect cycles with the from node, and we have
|
/* If we have indirect cycles with the from node, and we have
|
none on the to node, the to node has indirect cycles from the
|
none on the to node, the to node has indirect cycles from the
|
from node now that they are unified.
|
from node now that they are unified.
|
If indirect cycles exist on both, unify the nodes that they
|
If indirect cycles exist on both, unify the nodes that they
|
are in a cycle with, since we know they are in a cycle with
|
are in a cycle with, since we know they are in a cycle with
|
each other. */
|
each other. */
|
if (graph->indirect_cycles[to] == -1)
|
if (graph->indirect_cycles[to] == -1)
|
{
|
{
|
graph->indirect_cycles[to] = graph->indirect_cycles[from];
|
graph->indirect_cycles[to] = graph->indirect_cycles[from];
|
}
|
}
|
else
|
else
|
{
|
{
|
unsigned int tonode = find (graph->indirect_cycles[to]);
|
unsigned int tonode = find (graph->indirect_cycles[to]);
|
unsigned int fromnode = find (graph->indirect_cycles[from]);
|
unsigned int fromnode = find (graph->indirect_cycles[from]);
|
|
|
if (unite (tonode, fromnode))
|
if (unite (tonode, fromnode))
|
unify_nodes (graph, tonode, fromnode, true);
|
unify_nodes (graph, tonode, fromnode, true);
|
}
|
}
|
}
|
}
|
|
|
/* Merge all the successor edges. */
|
/* Merge all the successor edges. */
|
if (graph->succs[from])
|
if (graph->succs[from])
|
{
|
{
|
if (!graph->succs[to])
|
if (!graph->succs[to])
|
graph->succs[to] = BITMAP_ALLOC (&pta_obstack);
|
graph->succs[to] = BITMAP_ALLOC (&pta_obstack);
|
bitmap_ior_into (graph->succs[to],
|
bitmap_ior_into (graph->succs[to],
|
graph->succs[from]);
|
graph->succs[from]);
|
}
|
}
|
|
|
clear_edges_for_node (graph, from);
|
clear_edges_for_node (graph, from);
|
}
|
}
|
|
|
|
|
/* Add an indirect graph edge to GRAPH, going from TO to FROM if
|
/* Add an indirect graph edge to GRAPH, going from TO to FROM if
|
it doesn't exist in the graph already. */
|
it doesn't exist in the graph already. */
|
|
|
static void
|
static void
|
add_implicit_graph_edge (constraint_graph_t graph, unsigned int to,
|
add_implicit_graph_edge (constraint_graph_t graph, unsigned int to,
|
unsigned int from)
|
unsigned int from)
|
{
|
{
|
if (to == from)
|
if (to == from)
|
return;
|
return;
|
|
|
if (!graph->implicit_preds[to])
|
if (!graph->implicit_preds[to])
|
graph->implicit_preds[to] = BITMAP_ALLOC (&predbitmap_obstack);
|
graph->implicit_preds[to] = BITMAP_ALLOC (&predbitmap_obstack);
|
|
|
if (!bitmap_bit_p (graph->implicit_preds[to], from))
|
if (!bitmap_bit_p (graph->implicit_preds[to], from))
|
{
|
{
|
stats.num_implicit_edges++;
|
stats.num_implicit_edges++;
|
bitmap_set_bit (graph->implicit_preds[to], from);
|
bitmap_set_bit (graph->implicit_preds[to], from);
|
}
|
}
|
}
|
}
|
|
|
/* Add a predecessor graph edge to GRAPH, going from TO to FROM if
|
/* Add a predecessor graph edge to GRAPH, going from TO to FROM if
|
it doesn't exist in the graph already.
|
it doesn't exist in the graph already.
|
Return false if the edge already existed, true otherwise. */
|
Return false if the edge already existed, true otherwise. */
|
|
|
static void
|
static void
|
add_pred_graph_edge (constraint_graph_t graph, unsigned int to,
|
add_pred_graph_edge (constraint_graph_t graph, unsigned int to,
|
unsigned int from)
|
unsigned int from)
|
{
|
{
|
if (!graph->preds[to])
|
if (!graph->preds[to])
|
graph->preds[to] = BITMAP_ALLOC (&predbitmap_obstack);
|
graph->preds[to] = BITMAP_ALLOC (&predbitmap_obstack);
|
if (!bitmap_bit_p (graph->preds[to], from))
|
if (!bitmap_bit_p (graph->preds[to], from))
|
bitmap_set_bit (graph->preds[to], from);
|
bitmap_set_bit (graph->preds[to], from);
|
}
|
}
|
|
|
/* Add a graph edge to GRAPH, going from FROM to TO if
|
/* Add a graph edge to GRAPH, going from FROM to TO if
|
it doesn't exist in the graph already.
|
it doesn't exist in the graph already.
|
Return false if the edge already existed, true otherwise. */
|
Return false if the edge already existed, true otherwise. */
|
|
|
static bool
|
static bool
|
add_graph_edge (constraint_graph_t graph, unsigned int to,
|
add_graph_edge (constraint_graph_t graph, unsigned int to,
|
unsigned int from)
|
unsigned int from)
|
{
|
{
|
if (to == from)
|
if (to == from)
|
{
|
{
|
return false;
|
return false;
|
}
|
}
|
else
|
else
|
{
|
{
|
bool r = false;
|
bool r = false;
|
|
|
if (!graph->succs[from])
|
if (!graph->succs[from])
|
graph->succs[from] = BITMAP_ALLOC (&pta_obstack);
|
graph->succs[from] = BITMAP_ALLOC (&pta_obstack);
|
if (!bitmap_bit_p (graph->succs[from], to))
|
if (!bitmap_bit_p (graph->succs[from], to))
|
{
|
{
|
r = true;
|
r = true;
|
if (to < FIRST_REF_NODE && from < FIRST_REF_NODE)
|
if (to < FIRST_REF_NODE && from < FIRST_REF_NODE)
|
stats.num_edges++;
|
stats.num_edges++;
|
bitmap_set_bit (graph->succs[from], to);
|
bitmap_set_bit (graph->succs[from], to);
|
}
|
}
|
return r;
|
return r;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Return true if {DEST.SRC} is an existing graph edge in GRAPH. */
|
/* Return true if {DEST.SRC} is an existing graph edge in GRAPH. */
|
|
|
static bool
|
static bool
|
valid_graph_edge (constraint_graph_t graph, unsigned int src,
|
valid_graph_edge (constraint_graph_t graph, unsigned int src,
|
unsigned int dest)
|
unsigned int dest)
|
{
|
{
|
return (graph->succs[dest]
|
return (graph->succs[dest]
|
&& bitmap_bit_p (graph->succs[dest], src));
|
&& bitmap_bit_p (graph->succs[dest], src));
|
}
|
}
|
|
|
/* Build the constraint graph, adding only predecessor edges right now. */
|
/* Build the constraint graph, adding only predecessor edges right now. */
|
|
|
static void
|
static void
|
build_pred_graph (void)
|
build_pred_graph (void)
|
{
|
{
|
int i;
|
int i;
|
constraint_t c;
|
constraint_t c;
|
unsigned int j;
|
unsigned int j;
|
|
|
graph = XNEW (struct constraint_graph);
|
graph = XNEW (struct constraint_graph);
|
graph->size = (VEC_length (varinfo_t, varmap)) * 3;
|
graph->size = (VEC_length (varinfo_t, varmap)) * 3;
|
graph->succs = XCNEWVEC (bitmap, graph->size);
|
graph->succs = XCNEWVEC (bitmap, graph->size);
|
graph->implicit_preds = XCNEWVEC (bitmap, graph->size);
|
graph->implicit_preds = XCNEWVEC (bitmap, graph->size);
|
graph->preds = XCNEWVEC (bitmap, graph->size);
|
graph->preds = XCNEWVEC (bitmap, graph->size);
|
graph->indirect_cycles = XNEWVEC (int, VEC_length (varinfo_t, varmap));
|
graph->indirect_cycles = XNEWVEC (int, VEC_length (varinfo_t, varmap));
|
graph->label = XCNEWVEC (unsigned int, graph->size);
|
graph->label = XCNEWVEC (unsigned int, graph->size);
|
graph->rep = XNEWVEC (unsigned int, graph->size);
|
graph->rep = XNEWVEC (unsigned int, graph->size);
|
graph->eq_rep = XNEWVEC (int, graph->size);
|
graph->eq_rep = XNEWVEC (int, graph->size);
|
graph->complex = XCNEWVEC (VEC(constraint_t, heap) *,
|
graph->complex = XCNEWVEC (VEC(constraint_t, heap) *,
|
VEC_length (varinfo_t, varmap));
|
VEC_length (varinfo_t, varmap));
|
graph->direct_nodes = sbitmap_alloc (graph->size);
|
graph->direct_nodes = sbitmap_alloc (graph->size);
|
sbitmap_zero (graph->direct_nodes);
|
sbitmap_zero (graph->direct_nodes);
|
|
|
for (j = 0; j < FIRST_REF_NODE; j++)
|
for (j = 0; j < FIRST_REF_NODE; j++)
|
{
|
{
|
if (!get_varinfo (j)->is_special_var)
|
if (!get_varinfo (j)->is_special_var)
|
SET_BIT (graph->direct_nodes, j);
|
SET_BIT (graph->direct_nodes, j);
|
}
|
}
|
|
|
for (j = 0; j < graph->size; j++)
|
for (j = 0; j < graph->size; j++)
|
{
|
{
|
graph->rep[j] = j;
|
graph->rep[j] = j;
|
graph->eq_rep[j] = -1;
|
graph->eq_rep[j] = -1;
|
}
|
}
|
|
|
for (j = 0; j < VEC_length (varinfo_t, varmap); j++)
|
for (j = 0; j < VEC_length (varinfo_t, varmap); j++)
|
graph->indirect_cycles[j] = -1;
|
graph->indirect_cycles[j] = -1;
|
|
|
for (i = 0; VEC_iterate (constraint_t, constraints, i, c); i++)
|
for (i = 0; VEC_iterate (constraint_t, constraints, i, c); i++)
|
{
|
{
|
struct constraint_expr lhs = c->lhs;
|
struct constraint_expr lhs = c->lhs;
|
struct constraint_expr rhs = c->rhs;
|
struct constraint_expr rhs = c->rhs;
|
unsigned int lhsvar = get_varinfo_fc (lhs.var)->id;
|
unsigned int lhsvar = get_varinfo_fc (lhs.var)->id;
|
unsigned int rhsvar = get_varinfo_fc (rhs.var)->id;
|
unsigned int rhsvar = get_varinfo_fc (rhs.var)->id;
|
|
|
if (lhs.type == DEREF)
|
if (lhs.type == DEREF)
|
{
|
{
|
/* *x = y. */
|
/* *x = y. */
|
if (rhs.offset == 0 && lhs.offset == 0 && rhs.type == SCALAR)
|
if (rhs.offset == 0 && lhs.offset == 0 && rhs.type == SCALAR)
|
add_pred_graph_edge (graph, FIRST_REF_NODE + lhsvar, rhsvar);
|
add_pred_graph_edge (graph, FIRST_REF_NODE + lhsvar, rhsvar);
|
if (rhs.type == ADDRESSOF)
|
if (rhs.type == ADDRESSOF)
|
RESET_BIT (graph->direct_nodes, rhsvar);
|
RESET_BIT (graph->direct_nodes, rhsvar);
|
}
|
}
|
else if (rhs.type == DEREF)
|
else if (rhs.type == DEREF)
|
{
|
{
|
/* x = *y */
|
/* x = *y */
|
if (rhs.offset == 0 && lhs.offset == 0 && lhs.type == SCALAR)
|
if (rhs.offset == 0 && lhs.offset == 0 && lhs.type == SCALAR)
|
add_pred_graph_edge (graph, lhsvar, FIRST_REF_NODE + rhsvar);
|
add_pred_graph_edge (graph, lhsvar, FIRST_REF_NODE + rhsvar);
|
else
|
else
|
RESET_BIT (graph->direct_nodes, lhsvar);
|
RESET_BIT (graph->direct_nodes, lhsvar);
|
}
|
}
|
else if (rhs.type == ADDRESSOF)
|
else if (rhs.type == ADDRESSOF)
|
{
|
{
|
/* x = &y */
|
/* x = &y */
|
add_pred_graph_edge (graph, lhsvar, FIRST_ADDR_NODE + rhsvar);
|
add_pred_graph_edge (graph, lhsvar, FIRST_ADDR_NODE + rhsvar);
|
/* Implicitly, *x = y */
|
/* Implicitly, *x = y */
|
add_implicit_graph_edge (graph, FIRST_REF_NODE + lhsvar, rhsvar);
|
add_implicit_graph_edge (graph, FIRST_REF_NODE + lhsvar, rhsvar);
|
|
|
RESET_BIT (graph->direct_nodes, rhsvar);
|
RESET_BIT (graph->direct_nodes, rhsvar);
|
}
|
}
|
else if (lhsvar > anything_id
|
else if (lhsvar > anything_id
|
&& lhsvar != rhsvar && lhs.offset == 0 && rhs.offset == 0)
|
&& lhsvar != rhsvar && lhs.offset == 0 && rhs.offset == 0)
|
{
|
{
|
/* x = y */
|
/* x = y */
|
add_pred_graph_edge (graph, lhsvar, rhsvar);
|
add_pred_graph_edge (graph, lhsvar, rhsvar);
|
/* Implicitly, *x = *y */
|
/* Implicitly, *x = *y */
|
add_implicit_graph_edge (graph, FIRST_REF_NODE + lhsvar,
|
add_implicit_graph_edge (graph, FIRST_REF_NODE + lhsvar,
|
FIRST_REF_NODE + rhsvar);
|
FIRST_REF_NODE + rhsvar);
|
}
|
}
|
else if (lhs.offset != 0 || rhs.offset != 0)
|
else if (lhs.offset != 0 || rhs.offset != 0)
|
{
|
{
|
if (rhs.offset != 0)
|
if (rhs.offset != 0)
|
RESET_BIT (graph->direct_nodes, lhs.var);
|
RESET_BIT (graph->direct_nodes, lhs.var);
|
if (lhs.offset != 0)
|
if (lhs.offset != 0)
|
RESET_BIT (graph->direct_nodes, rhs.var);
|
RESET_BIT (graph->direct_nodes, rhs.var);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Build the constraint graph, adding successor edges. */
|
/* Build the constraint graph, adding successor edges. */
|
|
|
static void
|
static void
|
build_succ_graph (void)
|
build_succ_graph (void)
|
{
|
{
|
int i;
|
int i;
|
constraint_t c;
|
constraint_t c;
|
|
|
for (i = 0; VEC_iterate (constraint_t, constraints, i, c); i++)
|
for (i = 0; VEC_iterate (constraint_t, constraints, i, c); i++)
|
{
|
{
|
struct constraint_expr lhs;
|
struct constraint_expr lhs;
|
struct constraint_expr rhs;
|
struct constraint_expr rhs;
|
unsigned int lhsvar;
|
unsigned int lhsvar;
|
unsigned int rhsvar;
|
unsigned int rhsvar;
|
|
|
if (!c)
|
if (!c)
|
continue;
|
continue;
|
|
|
lhs = c->lhs;
|
lhs = c->lhs;
|
rhs = c->rhs;
|
rhs = c->rhs;
|
lhsvar = find (get_varinfo_fc (lhs.var)->id);
|
lhsvar = find (get_varinfo_fc (lhs.var)->id);
|
rhsvar = find (get_varinfo_fc (rhs.var)->id);
|
rhsvar = find (get_varinfo_fc (rhs.var)->id);
|
|
|
if (lhs.type == DEREF)
|
if (lhs.type == DEREF)
|
{
|
{
|
if (rhs.offset == 0 && lhs.offset == 0 && rhs.type == SCALAR)
|
if (rhs.offset == 0 && lhs.offset == 0 && rhs.type == SCALAR)
|
add_graph_edge (graph, FIRST_REF_NODE + lhsvar, rhsvar);
|
add_graph_edge (graph, FIRST_REF_NODE + lhsvar, rhsvar);
|
}
|
}
|
else if (rhs.type == DEREF)
|
else if (rhs.type == DEREF)
|
{
|
{
|
if (rhs.offset == 0 && lhs.offset == 0 && lhs.type == SCALAR)
|
if (rhs.offset == 0 && lhs.offset == 0 && lhs.type == SCALAR)
|
add_graph_edge (graph, lhsvar, FIRST_REF_NODE + rhsvar);
|
add_graph_edge (graph, lhsvar, FIRST_REF_NODE + rhsvar);
|
}
|
}
|
else if (rhs.type == ADDRESSOF)
|
else if (rhs.type == ADDRESSOF)
|
{
|
{
|
/* x = &y */
|
/* x = &y */
|
gcc_assert (find (get_varinfo_fc (rhs.var)->id)
|
gcc_assert (find (get_varinfo_fc (rhs.var)->id)
|
== get_varinfo_fc (rhs.var)->id);
|
== get_varinfo_fc (rhs.var)->id);
|
bitmap_set_bit (get_varinfo (lhsvar)->solution, rhsvar);
|
bitmap_set_bit (get_varinfo (lhsvar)->solution, rhsvar);
|
}
|
}
|
else if (lhsvar > anything_id
|
else if (lhsvar > anything_id
|
&& lhsvar != rhsvar && lhs.offset == 0 && rhs.offset == 0)
|
&& lhsvar != rhsvar && lhs.offset == 0 && rhs.offset == 0)
|
{
|
{
|
add_graph_edge (graph, lhsvar, rhsvar);
|
add_graph_edge (graph, lhsvar, rhsvar);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Changed variables on the last iteration. */
|
/* Changed variables on the last iteration. */
|
static unsigned int changed_count;
|
static unsigned int changed_count;
|
static sbitmap changed;
|
static sbitmap changed;
|
|
|
DEF_VEC_I(unsigned);
|
DEF_VEC_I(unsigned);
|
DEF_VEC_ALLOC_I(unsigned,heap);
|
DEF_VEC_ALLOC_I(unsigned,heap);
|
|
|
|
|
/* Strongly Connected Component visitation info. */
|
/* Strongly Connected Component visitation info. */
|
|
|
struct scc_info
|
struct scc_info
|
{
|
{
|
sbitmap visited;
|
sbitmap visited;
|
sbitmap roots;
|
sbitmap roots;
|
unsigned int *dfs;
|
unsigned int *dfs;
|
unsigned int *node_mapping;
|
unsigned int *node_mapping;
|
int current_index;
|
int current_index;
|
VEC(unsigned,heap) *scc_stack;
|
VEC(unsigned,heap) *scc_stack;
|
};
|
};
|
|
|
|
|
/* Recursive routine to find strongly connected components in GRAPH.
|
/* Recursive routine to find strongly connected components in GRAPH.
|
SI is the SCC info to store the information in, and N is the id of current
|
SI is the SCC info to store the information in, and N is the id of current
|
graph node we are processing.
|
graph node we are processing.
|
|
|
This is Tarjan's strongly connected component finding algorithm, as
|
This is Tarjan's strongly connected component finding algorithm, as
|
modified by Nuutila to keep only non-root nodes on the stack.
|
modified by Nuutila to keep only non-root nodes on the stack.
|
The algorithm can be found in "On finding the strongly connected
|
The algorithm can be found in "On finding the strongly connected
|
connected components in a directed graph" by Esko Nuutila and Eljas
|
connected components in a directed graph" by Esko Nuutila and Eljas
|
Soisalon-Soininen, in Information Processing Letters volume 49,
|
Soisalon-Soininen, in Information Processing Letters volume 49,
|
number 1, pages 9-14. */
|
number 1, pages 9-14. */
|
|
|
static void
|
static void
|
scc_visit (constraint_graph_t graph, struct scc_info *si, unsigned int n)
|
scc_visit (constraint_graph_t graph, struct scc_info *si, unsigned int n)
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
unsigned int my_dfs;
|
unsigned int my_dfs;
|
|
|
SET_BIT (si->visited, n);
|
SET_BIT (si->visited, n);
|
si->dfs[n] = si->current_index ++;
|
si->dfs[n] = si->current_index ++;
|
my_dfs = si->dfs[n];
|
my_dfs = si->dfs[n];
|
|
|
/* Visit all the successors. */
|
/* Visit all the successors. */
|
EXECUTE_IF_IN_NONNULL_BITMAP (graph->succs[n], 0, i, bi)
|
EXECUTE_IF_IN_NONNULL_BITMAP (graph->succs[n], 0, i, bi)
|
{
|
{
|
unsigned int w;
|
unsigned int w;
|
|
|
if (i > LAST_REF_NODE)
|
if (i > LAST_REF_NODE)
|
break;
|
break;
|
|
|
w = find (i);
|
w = find (i);
|
if (TEST_BIT (si->roots, w))
|
if (TEST_BIT (si->roots, w))
|
continue;
|
continue;
|
|
|
if (!TEST_BIT (si->visited, w))
|
if (!TEST_BIT (si->visited, w))
|
scc_visit (graph, si, w);
|
scc_visit (graph, si, w);
|
{
|
{
|
unsigned int t = find (w);
|
unsigned int t = find (w);
|
unsigned int nnode = find (n);
|
unsigned int nnode = find (n);
|
gcc_assert (nnode == n);
|
gcc_assert (nnode == n);
|
|
|
if (si->dfs[t] < si->dfs[nnode])
|
if (si->dfs[t] < si->dfs[nnode])
|
si->dfs[n] = si->dfs[t];
|
si->dfs[n] = si->dfs[t];
|
}
|
}
|
}
|
}
|
|
|
/* See if any components have been identified. */
|
/* See if any components have been identified. */
|
if (si->dfs[n] == my_dfs)
|
if (si->dfs[n] == my_dfs)
|
{
|
{
|
if (VEC_length (unsigned, si->scc_stack) > 0
|
if (VEC_length (unsigned, si->scc_stack) > 0
|
&& si->dfs[VEC_last (unsigned, si->scc_stack)] >= my_dfs)
|
&& si->dfs[VEC_last (unsigned, si->scc_stack)] >= my_dfs)
|
{
|
{
|
bitmap scc = BITMAP_ALLOC (NULL);
|
bitmap scc = BITMAP_ALLOC (NULL);
|
bool have_ref_node = n >= FIRST_REF_NODE;
|
bool have_ref_node = n >= FIRST_REF_NODE;
|
unsigned int lowest_node;
|
unsigned int lowest_node;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
|
|
bitmap_set_bit (scc, n);
|
bitmap_set_bit (scc, n);
|
|
|
while (VEC_length (unsigned, si->scc_stack) != 0
|
while (VEC_length (unsigned, si->scc_stack) != 0
|
&& si->dfs[VEC_last (unsigned, si->scc_stack)] >= my_dfs)
|
&& si->dfs[VEC_last (unsigned, si->scc_stack)] >= my_dfs)
|
{
|
{
|
unsigned int w = VEC_pop (unsigned, si->scc_stack);
|
unsigned int w = VEC_pop (unsigned, si->scc_stack);
|
|
|
bitmap_set_bit (scc, w);
|
bitmap_set_bit (scc, w);
|
if (w >= FIRST_REF_NODE)
|
if (w >= FIRST_REF_NODE)
|
have_ref_node = true;
|
have_ref_node = true;
|
}
|
}
|
|
|
lowest_node = bitmap_first_set_bit (scc);
|
lowest_node = bitmap_first_set_bit (scc);
|
gcc_assert (lowest_node < FIRST_REF_NODE);
|
gcc_assert (lowest_node < FIRST_REF_NODE);
|
EXECUTE_IF_SET_IN_BITMAP (scc, 0, i, bi)
|
EXECUTE_IF_SET_IN_BITMAP (scc, 0, i, bi)
|
{
|
{
|
if (i < FIRST_REF_NODE)
|
if (i < FIRST_REF_NODE)
|
{
|
{
|
/* Mark this node for collapsing. */
|
/* Mark this node for collapsing. */
|
if (unite (lowest_node, i))
|
if (unite (lowest_node, i))
|
unify_nodes (graph, lowest_node, i, false);
|
unify_nodes (graph, lowest_node, i, false);
|
}
|
}
|
else
|
else
|
{
|
{
|
unite (lowest_node, i);
|
unite (lowest_node, i);
|
graph->indirect_cycles[i - FIRST_REF_NODE] = lowest_node;
|
graph->indirect_cycles[i - FIRST_REF_NODE] = lowest_node;
|
}
|
}
|
}
|
}
|
}
|
}
|
SET_BIT (si->roots, n);
|
SET_BIT (si->roots, n);
|
}
|
}
|
else
|
else
|
VEC_safe_push (unsigned, heap, si->scc_stack, n);
|
VEC_safe_push (unsigned, heap, si->scc_stack, n);
|
}
|
}
|
|
|
/* Unify node FROM into node TO, updating the changed count if
|
/* Unify node FROM into node TO, updating the changed count if
|
necessary when UPDATE_CHANGED is true. */
|
necessary when UPDATE_CHANGED is true. */
|
|
|
static void
|
static void
|
unify_nodes (constraint_graph_t graph, unsigned int to, unsigned int from,
|
unify_nodes (constraint_graph_t graph, unsigned int to, unsigned int from,
|
bool update_changed)
|
bool update_changed)
|
{
|
{
|
|
|
gcc_assert (to != from && find (to) == to);
|
gcc_assert (to != from && find (to) == to);
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
fprintf (dump_file, "Unifying %s to %s\n",
|
fprintf (dump_file, "Unifying %s to %s\n",
|
get_varinfo (from)->name,
|
get_varinfo (from)->name,
|
get_varinfo (to)->name);
|
get_varinfo (to)->name);
|
|
|
if (update_changed)
|
if (update_changed)
|
stats.unified_vars_dynamic++;
|
stats.unified_vars_dynamic++;
|
else
|
else
|
stats.unified_vars_static++;
|
stats.unified_vars_static++;
|
|
|
merge_graph_nodes (graph, to, from);
|
merge_graph_nodes (graph, to, from);
|
merge_node_constraints (graph, to, from);
|
merge_node_constraints (graph, to, from);
|
|
|
if (update_changed && TEST_BIT (changed, from))
|
if (update_changed && TEST_BIT (changed, from))
|
{
|
{
|
RESET_BIT (changed, from);
|
RESET_BIT (changed, from);
|
if (!TEST_BIT (changed, to))
|
if (!TEST_BIT (changed, to))
|
SET_BIT (changed, to);
|
SET_BIT (changed, to);
|
else
|
else
|
{
|
{
|
gcc_assert (changed_count > 0);
|
gcc_assert (changed_count > 0);
|
changed_count--;
|
changed_count--;
|
}
|
}
|
}
|
}
|
|
|
/* If the solution changes because of the merging, we need to mark
|
/* If the solution changes because of the merging, we need to mark
|
the variable as changed. */
|
the variable as changed. */
|
if (bitmap_ior_into (get_varinfo (to)->solution,
|
if (bitmap_ior_into (get_varinfo (to)->solution,
|
get_varinfo (from)->solution))
|
get_varinfo (from)->solution))
|
{
|
{
|
if (update_changed && !TEST_BIT (changed, to))
|
if (update_changed && !TEST_BIT (changed, to))
|
{
|
{
|
SET_BIT (changed, to);
|
SET_BIT (changed, to);
|
changed_count++;
|
changed_count++;
|
}
|
}
|
}
|
}
|
|
|
BITMAP_FREE (get_varinfo (from)->solution);
|
BITMAP_FREE (get_varinfo (from)->solution);
|
BITMAP_FREE (get_varinfo (from)->oldsolution);
|
BITMAP_FREE (get_varinfo (from)->oldsolution);
|
|
|
if (stats.iterations > 0)
|
if (stats.iterations > 0)
|
{
|
{
|
BITMAP_FREE (get_varinfo (to)->oldsolution);
|
BITMAP_FREE (get_varinfo (to)->oldsolution);
|
get_varinfo (to)->oldsolution = BITMAP_ALLOC (&oldpta_obstack);
|
get_varinfo (to)->oldsolution = BITMAP_ALLOC (&oldpta_obstack);
|
}
|
}
|
|
|
if (valid_graph_edge (graph, to, to))
|
if (valid_graph_edge (graph, to, to))
|
{
|
{
|
if (graph->succs[to])
|
if (graph->succs[to])
|
bitmap_clear_bit (graph->succs[to], to);
|
bitmap_clear_bit (graph->succs[to], to);
|
}
|
}
|
}
|
}
|
|
|
/* Information needed to compute the topological ordering of a graph. */
|
/* Information needed to compute the topological ordering of a graph. */
|
|
|
struct topo_info
|
struct topo_info
|
{
|
{
|
/* sbitmap of visited nodes. */
|
/* sbitmap of visited nodes. */
|
sbitmap visited;
|
sbitmap visited;
|
/* Array that stores the topological order of the graph, *in
|
/* Array that stores the topological order of the graph, *in
|
reverse*. */
|
reverse*. */
|
VEC(unsigned,heap) *topo_order;
|
VEC(unsigned,heap) *topo_order;
|
};
|
};
|
|
|
|
|
/* Initialize and return a topological info structure. */
|
/* Initialize and return a topological info structure. */
|
|
|
static struct topo_info *
|
static struct topo_info *
|
init_topo_info (void)
|
init_topo_info (void)
|
{
|
{
|
size_t size = VEC_length (varinfo_t, varmap);
|
size_t size = VEC_length (varinfo_t, varmap);
|
struct topo_info *ti = XNEW (struct topo_info);
|
struct topo_info *ti = XNEW (struct topo_info);
|
ti->visited = sbitmap_alloc (size);
|
ti->visited = sbitmap_alloc (size);
|
sbitmap_zero (ti->visited);
|
sbitmap_zero (ti->visited);
|
ti->topo_order = VEC_alloc (unsigned, heap, 1);
|
ti->topo_order = VEC_alloc (unsigned, heap, 1);
|
return ti;
|
return ti;
|
}
|
}
|
|
|
|
|
/* Free the topological sort info pointed to by TI. */
|
/* Free the topological sort info pointed to by TI. */
|
|
|
static void
|
static void
|
free_topo_info (struct topo_info *ti)
|
free_topo_info (struct topo_info *ti)
|
{
|
{
|
sbitmap_free (ti->visited);
|
sbitmap_free (ti->visited);
|
VEC_free (unsigned, heap, ti->topo_order);
|
VEC_free (unsigned, heap, ti->topo_order);
|
free (ti);
|
free (ti);
|
}
|
}
|
|
|
/* Visit the graph in topological order, and store the order in the
|
/* Visit the graph in topological order, and store the order in the
|
topo_info structure. */
|
topo_info structure. */
|
|
|
static void
|
static void
|
topo_visit (constraint_graph_t graph, struct topo_info *ti,
|
topo_visit (constraint_graph_t graph, struct topo_info *ti,
|
unsigned int n)
|
unsigned int n)
|
{
|
{
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
unsigned int j;
|
unsigned int j;
|
|
|
SET_BIT (ti->visited, n);
|
SET_BIT (ti->visited, n);
|
|
|
if (graph->succs[n])
|
if (graph->succs[n])
|
EXECUTE_IF_SET_IN_BITMAP (graph->succs[n], 0, j, bi)
|
EXECUTE_IF_SET_IN_BITMAP (graph->succs[n], 0, j, bi)
|
{
|
{
|
if (!TEST_BIT (ti->visited, j))
|
if (!TEST_BIT (ti->visited, j))
|
topo_visit (graph, ti, j);
|
topo_visit (graph, ti, j);
|
}
|
}
|
|
|
VEC_safe_push (unsigned, heap, ti->topo_order, n);
|
VEC_safe_push (unsigned, heap, ti->topo_order, n);
|
}
|
}
|
|
|
/* Return true if variable N + OFFSET is a legal field of N. */
|
/* Return true if variable N + OFFSET is a legal field of N. */
|
|
|
static bool
|
static bool
|
type_safe (unsigned int n, unsigned HOST_WIDE_INT *offset)
|
type_safe (unsigned int n, unsigned HOST_WIDE_INT *offset)
|
{
|
{
|
varinfo_t ninfo = get_varinfo (n);
|
varinfo_t ninfo = get_varinfo (n);
|
|
|
/* For things we've globbed to single variables, any offset into the
|
/* For things we've globbed to single variables, any offset into the
|
variable acts like the entire variable, so that it becomes offset
|
variable acts like the entire variable, so that it becomes offset
|
0. */
|
0. */
|
if (ninfo->is_special_var
|
if (ninfo->is_special_var
|
|| ninfo->is_artificial_var
|
|| ninfo->is_artificial_var
|
|| ninfo->is_unknown_size_var)
|
|| ninfo->is_unknown_size_var)
|
{
|
{
|
*offset = 0;
|
*offset = 0;
|
return true;
|
return true;
|
}
|
}
|
return (get_varinfo (n)->offset + *offset) < get_varinfo (n)->fullsize;
|
return (get_varinfo (n)->offset + *offset) < get_varinfo (n)->fullsize;
|
}
|
}
|
|
|
/* Process a constraint C that represents *x = &y. */
|
/* Process a constraint C that represents *x = &y. */
|
|
|
static void
|
static void
|
do_da_constraint (constraint_graph_t graph ATTRIBUTE_UNUSED,
|
do_da_constraint (constraint_graph_t graph ATTRIBUTE_UNUSED,
|
constraint_t c, bitmap delta)
|
constraint_t c, bitmap delta)
|
{
|
{
|
unsigned int rhs = c->rhs.var;
|
unsigned int rhs = c->rhs.var;
|
unsigned int j;
|
unsigned int j;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
|
|
/* For each member j of Delta (Sol(x)), add x to Sol(j) */
|
/* For each member j of Delta (Sol(x)), add x to Sol(j) */
|
EXECUTE_IF_SET_IN_BITMAP (delta, 0, j, bi)
|
EXECUTE_IF_SET_IN_BITMAP (delta, 0, j, bi)
|
{
|
{
|
unsigned HOST_WIDE_INT offset = c->lhs.offset;
|
unsigned HOST_WIDE_INT offset = c->lhs.offset;
|
if (type_safe (j, &offset) && !(get_varinfo (j)->is_special_var))
|
if (type_safe (j, &offset) && !(get_varinfo (j)->is_special_var))
|
{
|
{
|
/* *x != NULL && *x != ANYTHING*/
|
/* *x != NULL && *x != ANYTHING*/
|
varinfo_t v;
|
varinfo_t v;
|
unsigned int t;
|
unsigned int t;
|
bitmap sol;
|
bitmap sol;
|
unsigned HOST_WIDE_INT fieldoffset = get_varinfo (j)->offset + offset;
|
unsigned HOST_WIDE_INT fieldoffset = get_varinfo (j)->offset + offset;
|
|
|
v = first_vi_for_offset (get_varinfo (j), fieldoffset);
|
v = first_vi_for_offset (get_varinfo (j), fieldoffset);
|
if (!v)
|
if (!v)
|
continue;
|
continue;
|
t = find (v->id);
|
t = find (v->id);
|
sol = get_varinfo (t)->solution;
|
sol = get_varinfo (t)->solution;
|
if (!bitmap_bit_p (sol, rhs))
|
if (!bitmap_bit_p (sol, rhs))
|
{
|
{
|
bitmap_set_bit (sol, rhs);
|
bitmap_set_bit (sol, rhs);
|
if (!TEST_BIT (changed, t))
|
if (!TEST_BIT (changed, t))
|
{
|
{
|
SET_BIT (changed, t);
|
SET_BIT (changed, t);
|
changed_count++;
|
changed_count++;
|
}
|
}
|
}
|
}
|
}
|
}
|
else if (0 && dump_file && !(get_varinfo (j)->is_special_var))
|
else if (0 && dump_file && !(get_varinfo (j)->is_special_var))
|
fprintf (dump_file, "Untypesafe usage in do_da_constraint.\n");
|
fprintf (dump_file, "Untypesafe usage in do_da_constraint.\n");
|
|
|
}
|
}
|
}
|
}
|
|
|
/* Process a constraint C that represents x = *y, using DELTA as the
|
/* Process a constraint C that represents x = *y, using DELTA as the
|
starting solution. */
|
starting solution. */
|
|
|
static void
|
static void
|
do_sd_constraint (constraint_graph_t graph, constraint_t c,
|
do_sd_constraint (constraint_graph_t graph, constraint_t c,
|
bitmap delta)
|
bitmap delta)
|
{
|
{
|
unsigned int lhs = find (c->lhs.var);
|
unsigned int lhs = find (c->lhs.var);
|
bool flag = false;
|
bool flag = false;
|
bitmap sol = get_varinfo (lhs)->solution;
|
bitmap sol = get_varinfo (lhs)->solution;
|
unsigned int j;
|
unsigned int j;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
|
|
if (bitmap_bit_p (delta, anything_id))
|
if (bitmap_bit_p (delta, anything_id))
|
{
|
{
|
flag = !bitmap_bit_p (sol, anything_id);
|
flag = !bitmap_bit_p (sol, anything_id);
|
if (flag)
|
if (flag)
|
bitmap_set_bit (sol, anything_id);
|
bitmap_set_bit (sol, anything_id);
|
goto done;
|
goto done;
|
}
|
}
|
/* For each variable j in delta (Sol(y)), add
|
/* For each variable j in delta (Sol(y)), add
|
an edge in the graph from j to x, and union Sol(j) into Sol(x). */
|
an edge in the graph from j to x, and union Sol(j) into Sol(x). */
|
EXECUTE_IF_SET_IN_BITMAP (delta, 0, j, bi)
|
EXECUTE_IF_SET_IN_BITMAP (delta, 0, j, bi)
|
{
|
{
|
unsigned HOST_WIDE_INT roffset = c->rhs.offset;
|
unsigned HOST_WIDE_INT roffset = c->rhs.offset;
|
if (type_safe (j, &roffset))
|
if (type_safe (j, &roffset))
|
{
|
{
|
varinfo_t v;
|
varinfo_t v;
|
unsigned HOST_WIDE_INT fieldoffset = get_varinfo (j)->offset + roffset;
|
unsigned HOST_WIDE_INT fieldoffset = get_varinfo (j)->offset + roffset;
|
unsigned int t;
|
unsigned int t;
|
|
|
v = first_vi_for_offset (get_varinfo (j), fieldoffset);
|
v = first_vi_for_offset (get_varinfo (j), fieldoffset);
|
if (!v)
|
if (!v)
|
continue;
|
continue;
|
t = find (v->id);
|
t = find (v->id);
|
|
|
/* Adding edges from the special vars is pointless.
|
/* Adding edges from the special vars is pointless.
|
They don't have sets that can change. */
|
They don't have sets that can change. */
|
if (get_varinfo (t) ->is_special_var)
|
if (get_varinfo (t) ->is_special_var)
|
flag |= bitmap_ior_into (sol, get_varinfo (t)->solution);
|
flag |= bitmap_ior_into (sol, get_varinfo (t)->solution);
|
else if (add_graph_edge (graph, lhs, t))
|
else if (add_graph_edge (graph, lhs, t))
|
flag |= bitmap_ior_into (sol, get_varinfo (t)->solution);
|
flag |= bitmap_ior_into (sol, get_varinfo (t)->solution);
|
}
|
}
|
else if (0 && dump_file && !(get_varinfo (j)->is_special_var))
|
else if (0 && dump_file && !(get_varinfo (j)->is_special_var))
|
fprintf (dump_file, "Untypesafe usage in do_sd_constraint\n");
|
fprintf (dump_file, "Untypesafe usage in do_sd_constraint\n");
|
|
|
}
|
}
|
|
|
done:
|
done:
|
/* If the LHS solution changed, mark the var as changed. */
|
/* If the LHS solution changed, mark the var as changed. */
|
if (flag)
|
if (flag)
|
{
|
{
|
get_varinfo (lhs)->solution = sol;
|
get_varinfo (lhs)->solution = sol;
|
if (!TEST_BIT (changed, lhs))
|
if (!TEST_BIT (changed, lhs))
|
{
|
{
|
SET_BIT (changed, lhs);
|
SET_BIT (changed, lhs);
|
changed_count++;
|
changed_count++;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Process a constraint C that represents *x = y. */
|
/* Process a constraint C that represents *x = y. */
|
|
|
static void
|
static void
|
do_ds_constraint (constraint_t c, bitmap delta)
|
do_ds_constraint (constraint_t c, bitmap delta)
|
{
|
{
|
unsigned int rhs = find (c->rhs.var);
|
unsigned int rhs = find (c->rhs.var);
|
unsigned HOST_WIDE_INT roff = c->rhs.offset;
|
unsigned HOST_WIDE_INT roff = c->rhs.offset;
|
bitmap sol = get_varinfo (rhs)->solution;
|
bitmap sol = get_varinfo (rhs)->solution;
|
unsigned int j;
|
unsigned int j;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
|
|
if (bitmap_bit_p (sol, anything_id))
|
if (bitmap_bit_p (sol, anything_id))
|
{
|
{
|
EXECUTE_IF_SET_IN_BITMAP (delta, 0, j, bi)
|
EXECUTE_IF_SET_IN_BITMAP (delta, 0, j, bi)
|
{
|
{
|
varinfo_t jvi = get_varinfo (j);
|
varinfo_t jvi = get_varinfo (j);
|
unsigned int t;
|
unsigned int t;
|
unsigned int loff = c->lhs.offset;
|
unsigned int loff = c->lhs.offset;
|
unsigned HOST_WIDE_INT fieldoffset = jvi->offset + loff;
|
unsigned HOST_WIDE_INT fieldoffset = jvi->offset + loff;
|
varinfo_t v;
|
varinfo_t v;
|
|
|
v = first_vi_for_offset (get_varinfo (j), fieldoffset);
|
v = first_vi_for_offset (get_varinfo (j), fieldoffset);
|
if (!v)
|
if (!v)
|
continue;
|
continue;
|
t = find (v->id);
|
t = find (v->id);
|
|
|
if (!bitmap_bit_p (get_varinfo (t)->solution, anything_id))
|
if (!bitmap_bit_p (get_varinfo (t)->solution, anything_id))
|
{
|
{
|
bitmap_set_bit (get_varinfo (t)->solution, anything_id);
|
bitmap_set_bit (get_varinfo (t)->solution, anything_id);
|
if (!TEST_BIT (changed, t))
|
if (!TEST_BIT (changed, t))
|
{
|
{
|
SET_BIT (changed, t);
|
SET_BIT (changed, t);
|
changed_count++;
|
changed_count++;
|
}
|
}
|
}
|
}
|
}
|
}
|
return;
|
return;
|
}
|
}
|
|
|
/* For each member j of delta (Sol(x)), add an edge from y to j and
|
/* For each member j of delta (Sol(x)), add an edge from y to j and
|
union Sol(y) into Sol(j) */
|
union Sol(y) into Sol(j) */
|
EXECUTE_IF_SET_IN_BITMAP (delta, 0, j, bi)
|
EXECUTE_IF_SET_IN_BITMAP (delta, 0, j, bi)
|
{
|
{
|
unsigned HOST_WIDE_INT loff = c->lhs.offset;
|
unsigned HOST_WIDE_INT loff = c->lhs.offset;
|
if (type_safe (j, &loff) && !(get_varinfo (j)->is_special_var))
|
if (type_safe (j, &loff) && !(get_varinfo (j)->is_special_var))
|
{
|
{
|
varinfo_t v;
|
varinfo_t v;
|
unsigned int t;
|
unsigned int t;
|
unsigned HOST_WIDE_INT fieldoffset = get_varinfo (j)->offset + loff;
|
unsigned HOST_WIDE_INT fieldoffset = get_varinfo (j)->offset + loff;
|
bitmap tmp;
|
bitmap tmp;
|
|
|
v = first_vi_for_offset (get_varinfo (j), fieldoffset);
|
v = first_vi_for_offset (get_varinfo (j), fieldoffset);
|
if (!v)
|
if (!v)
|
continue;
|
continue;
|
t = find (v->id);
|
t = find (v->id);
|
tmp = get_varinfo (t)->solution;
|
tmp = get_varinfo (t)->solution;
|
|
|
if (set_union_with_increment (tmp, sol, roff))
|
if (set_union_with_increment (tmp, sol, roff))
|
{
|
{
|
get_varinfo (t)->solution = tmp;
|
get_varinfo (t)->solution = tmp;
|
if (t == rhs)
|
if (t == rhs)
|
sol = get_varinfo (rhs)->solution;
|
sol = get_varinfo (rhs)->solution;
|
if (!TEST_BIT (changed, t))
|
if (!TEST_BIT (changed, t))
|
{
|
{
|
SET_BIT (changed, t);
|
SET_BIT (changed, t);
|
changed_count++;
|
changed_count++;
|
}
|
}
|
}
|
}
|
}
|
}
|
else if (0 && dump_file && !(get_varinfo (j)->is_special_var))
|
else if (0 && dump_file && !(get_varinfo (j)->is_special_var))
|
fprintf (dump_file, "Untypesafe usage in do_ds_constraint\n");
|
fprintf (dump_file, "Untypesafe usage in do_ds_constraint\n");
|
}
|
}
|
}
|
}
|
|
|
/* Handle a non-simple (simple meaning requires no iteration),
|
/* Handle a non-simple (simple meaning requires no iteration),
|
constraint (IE *x = &y, x = *y, *x = y, and x = y with offsets involved). */
|
constraint (IE *x = &y, x = *y, *x = y, and x = y with offsets involved). */
|
|
|
static void
|
static void
|
do_complex_constraint (constraint_graph_t graph, constraint_t c, bitmap delta)
|
do_complex_constraint (constraint_graph_t graph, constraint_t c, bitmap delta)
|
{
|
{
|
if (c->lhs.type == DEREF)
|
if (c->lhs.type == DEREF)
|
{
|
{
|
if (c->rhs.type == ADDRESSOF)
|
if (c->rhs.type == ADDRESSOF)
|
{
|
{
|
/* *x = &y */
|
/* *x = &y */
|
do_da_constraint (graph, c, delta);
|
do_da_constraint (graph, c, delta);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* *x = y */
|
/* *x = y */
|
do_ds_constraint (c, delta);
|
do_ds_constraint (c, delta);
|
}
|
}
|
}
|
}
|
else if (c->rhs.type == DEREF)
|
else if (c->rhs.type == DEREF)
|
{
|
{
|
/* x = *y */
|
/* x = *y */
|
if (!(get_varinfo (c->lhs.var)->is_special_var))
|
if (!(get_varinfo (c->lhs.var)->is_special_var))
|
do_sd_constraint (graph, c, delta);
|
do_sd_constraint (graph, c, delta);
|
}
|
}
|
else
|
else
|
{
|
{
|
bitmap tmp;
|
bitmap tmp;
|
bitmap solution;
|
bitmap solution;
|
bool flag = false;
|
bool flag = false;
|
unsigned int t;
|
unsigned int t;
|
|
|
gcc_assert (c->rhs.type == SCALAR && c->lhs.type == SCALAR);
|
gcc_assert (c->rhs.type == SCALAR && c->lhs.type == SCALAR);
|
t = find (c->rhs.var);
|
t = find (c->rhs.var);
|
solution = get_varinfo (t)->solution;
|
solution = get_varinfo (t)->solution;
|
t = find (c->lhs.var);
|
t = find (c->lhs.var);
|
tmp = get_varinfo (t)->solution;
|
tmp = get_varinfo (t)->solution;
|
|
|
flag = set_union_with_increment (tmp, solution, c->rhs.offset);
|
flag = set_union_with_increment (tmp, solution, c->rhs.offset);
|
|
|
if (flag)
|
if (flag)
|
{
|
{
|
get_varinfo (t)->solution = tmp;
|
get_varinfo (t)->solution = tmp;
|
if (!TEST_BIT (changed, t))
|
if (!TEST_BIT (changed, t))
|
{
|
{
|
SET_BIT (changed, t);
|
SET_BIT (changed, t);
|
changed_count++;
|
changed_count++;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Initialize and return a new SCC info structure. */
|
/* Initialize and return a new SCC info structure. */
|
|
|
static struct scc_info *
|
static struct scc_info *
|
init_scc_info (size_t size)
|
init_scc_info (size_t size)
|
{
|
{
|
struct scc_info *si = XNEW (struct scc_info);
|
struct scc_info *si = XNEW (struct scc_info);
|
size_t i;
|
size_t i;
|
|
|
si->current_index = 0;
|
si->current_index = 0;
|
si->visited = sbitmap_alloc (size);
|
si->visited = sbitmap_alloc (size);
|
sbitmap_zero (si->visited);
|
sbitmap_zero (si->visited);
|
si->roots = sbitmap_alloc (size);
|
si->roots = sbitmap_alloc (size);
|
sbitmap_zero (si->roots);
|
sbitmap_zero (si->roots);
|
si->node_mapping = XNEWVEC (unsigned int, size);
|
si->node_mapping = XNEWVEC (unsigned int, size);
|
si->dfs = XCNEWVEC (unsigned int, size);
|
si->dfs = XCNEWVEC (unsigned int, size);
|
|
|
for (i = 0; i < size; i++)
|
for (i = 0; i < size; i++)
|
si->node_mapping[i] = i;
|
si->node_mapping[i] = i;
|
|
|
si->scc_stack = VEC_alloc (unsigned, heap, 1);
|
si->scc_stack = VEC_alloc (unsigned, heap, 1);
|
return si;
|
return si;
|
}
|
}
|
|
|
/* Free an SCC info structure pointed to by SI */
|
/* Free an SCC info structure pointed to by SI */
|
|
|
static void
|
static void
|
free_scc_info (struct scc_info *si)
|
free_scc_info (struct scc_info *si)
|
{
|
{
|
sbitmap_free (si->visited);
|
sbitmap_free (si->visited);
|
sbitmap_free (si->roots);
|
sbitmap_free (si->roots);
|
free (si->node_mapping);
|
free (si->node_mapping);
|
free (si->dfs);
|
free (si->dfs);
|
VEC_free (unsigned, heap, si->scc_stack);
|
VEC_free (unsigned, heap, si->scc_stack);
|
free (si);
|
free (si);
|
}
|
}
|
|
|
|
|
/* Find indirect cycles in GRAPH that occur, using strongly connected
|
/* Find indirect cycles in GRAPH that occur, using strongly connected
|
components, and note them in the indirect cycles map.
|
components, and note them in the indirect cycles map.
|
|
|
This technique comes from Ben Hardekopf and Calvin Lin,
|
This technique comes from Ben Hardekopf and Calvin Lin,
|
"It Pays to be Lazy: Fast and Accurate Pointer Analysis for Millions of
|
"It Pays to be Lazy: Fast and Accurate Pointer Analysis for Millions of
|
Lines of Code", submitted to PLDI 2007. */
|
Lines of Code", submitted to PLDI 2007. */
|
|
|
static void
|
static void
|
find_indirect_cycles (constraint_graph_t graph)
|
find_indirect_cycles (constraint_graph_t graph)
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
unsigned int size = graph->size;
|
unsigned int size = graph->size;
|
struct scc_info *si = init_scc_info (size);
|
struct scc_info *si = init_scc_info (size);
|
|
|
for (i = 0; i < MIN (LAST_REF_NODE, size); i ++ )
|
for (i = 0; i < MIN (LAST_REF_NODE, size); i ++ )
|
if (!TEST_BIT (si->visited, i) && find (i) == i)
|
if (!TEST_BIT (si->visited, i) && find (i) == i)
|
scc_visit (graph, si, i);
|
scc_visit (graph, si, i);
|
|
|
free_scc_info (si);
|
free_scc_info (si);
|
}
|
}
|
|
|
/* Compute a topological ordering for GRAPH, and store the result in the
|
/* Compute a topological ordering for GRAPH, and store the result in the
|
topo_info structure TI. */
|
topo_info structure TI. */
|
|
|
static void
|
static void
|
compute_topo_order (constraint_graph_t graph,
|
compute_topo_order (constraint_graph_t graph,
|
struct topo_info *ti)
|
struct topo_info *ti)
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
unsigned int size = VEC_length (varinfo_t, varmap);
|
unsigned int size = VEC_length (varinfo_t, varmap);
|
|
|
for (i = 0; i != size; ++i)
|
for (i = 0; i != size; ++i)
|
if (!TEST_BIT (ti->visited, i) && find (i) == i)
|
if (!TEST_BIT (ti->visited, i) && find (i) == i)
|
topo_visit (graph, ti, i);
|
topo_visit (graph, ti, i);
|
}
|
}
|
|
|
/* Perform offline variable substitution.
|
/* Perform offline variable substitution.
|
|
|
This is a linear time way of identifying variables that must have
|
This is a linear time way of identifying variables that must have
|
equivalent points-to sets, including those caused by static cycles,
|
equivalent points-to sets, including those caused by static cycles,
|
and single entry subgraphs, in the constraint graph.
|
and single entry subgraphs, in the constraint graph.
|
|
|
The technique is described in "Off-line variable substitution for
|
The technique is described in "Off-line variable substitution for
|
scaling points-to analysis" by Atanas Rountev and Satish Chandra,
|
scaling points-to analysis" by Atanas Rountev and Satish Chandra,
|
in "ACM SIGPLAN Notices" volume 35, number 5, pages 47-56.
|
in "ACM SIGPLAN Notices" volume 35, number 5, pages 47-56.
|
|
|
There is an optimal way to do this involving hash based value
|
There is an optimal way to do this involving hash based value
|
numbering, once the technique is published i will implement it
|
numbering, once the technique is published i will implement it
|
here.
|
here.
|
|
|
The general method of finding equivalence classes is as follows:
|
The general method of finding equivalence classes is as follows:
|
Add fake nodes (REF nodes) and edges for *a = b and a = *b constraints.
|
Add fake nodes (REF nodes) and edges for *a = b and a = *b constraints.
|
Add fake nodes (ADDRESS nodes) and edges for a = &b constraints.
|
Add fake nodes (ADDRESS nodes) and edges for a = &b constraints.
|
Initialize all non-REF/ADDRESS nodes to be direct nodes
|
Initialize all non-REF/ADDRESS nodes to be direct nodes
|
For each SCC in the predecessor graph:
|
For each SCC in the predecessor graph:
|
for each member (x) of the SCC
|
for each member (x) of the SCC
|
if x is not a direct node:
|
if x is not a direct node:
|
set rootnode(SCC) to be not a direct node
|
set rootnode(SCC) to be not a direct node
|
collapse node x into rootnode(SCC).
|
collapse node x into rootnode(SCC).
|
if rootnode(SCC) is not a direct node:
|
if rootnode(SCC) is not a direct node:
|
label rootnode(SCC) with a new equivalence class
|
label rootnode(SCC) with a new equivalence class
|
else:
|
else:
|
if all labeled predecessors of rootnode(SCC) have the same
|
if all labeled predecessors of rootnode(SCC) have the same
|
label:
|
label:
|
label rootnode(SCC) with this label
|
label rootnode(SCC) with this label
|
else:
|
else:
|
label rootnode(SCC) with a new equivalence class
|
label rootnode(SCC) with a new equivalence class
|
|
|
All direct nodes with the same equivalence class can be replaced
|
All direct nodes with the same equivalence class can be replaced
|
with a single representative node.
|
with a single representative node.
|
All unlabeled nodes (label == 0) are not pointers and all edges
|
All unlabeled nodes (label == 0) are not pointers and all edges
|
involving them can be eliminated.
|
involving them can be eliminated.
|
We perform these optimizations during move_complex_constraints.
|
We perform these optimizations during move_complex_constraints.
|
*/
|
*/
|
|
|
static int equivalence_class;
|
static int equivalence_class;
|
|
|
/* Recursive routine to find strongly connected components in GRAPH,
|
/* Recursive routine to find strongly connected components in GRAPH,
|
and label it's nodes with equivalence classes.
|
and label it's nodes with equivalence classes.
|
This is used during variable substitution to find cycles involving
|
This is used during variable substitution to find cycles involving
|
the regular or implicit predecessors, and label them as equivalent.
|
the regular or implicit predecessors, and label them as equivalent.
|
The SCC finding algorithm used is the same as that for scc_visit. */
|
The SCC finding algorithm used is the same as that for scc_visit. */
|
|
|
static void
|
static void
|
label_visit (constraint_graph_t graph, struct scc_info *si, unsigned int n)
|
label_visit (constraint_graph_t graph, struct scc_info *si, unsigned int n)
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
unsigned int my_dfs;
|
unsigned int my_dfs;
|
|
|
gcc_assert (si->node_mapping[n] == n);
|
gcc_assert (si->node_mapping[n] == n);
|
SET_BIT (si->visited, n);
|
SET_BIT (si->visited, n);
|
si->dfs[n] = si->current_index ++;
|
si->dfs[n] = si->current_index ++;
|
my_dfs = si->dfs[n];
|
my_dfs = si->dfs[n];
|
|
|
/* Visit all the successors. */
|
/* Visit all the successors. */
|
EXECUTE_IF_IN_NONNULL_BITMAP (graph->preds[n], 0, i, bi)
|
EXECUTE_IF_IN_NONNULL_BITMAP (graph->preds[n], 0, i, bi)
|
{
|
{
|
unsigned int w = si->node_mapping[i];
|
unsigned int w = si->node_mapping[i];
|
|
|
if (TEST_BIT (si->roots, w))
|
if (TEST_BIT (si->roots, w))
|
continue;
|
continue;
|
|
|
if (!TEST_BIT (si->visited, w))
|
if (!TEST_BIT (si->visited, w))
|
label_visit (graph, si, w);
|
label_visit (graph, si, w);
|
{
|
{
|
unsigned int t = si->node_mapping[w];
|
unsigned int t = si->node_mapping[w];
|
unsigned int nnode = si->node_mapping[n];
|
unsigned int nnode = si->node_mapping[n];
|
gcc_assert (nnode == n);
|
gcc_assert (nnode == n);
|
|
|
if (si->dfs[t] < si->dfs[nnode])
|
if (si->dfs[t] < si->dfs[nnode])
|
si->dfs[n] = si->dfs[t];
|
si->dfs[n] = si->dfs[t];
|
}
|
}
|
}
|
}
|
|
|
/* Visit all the implicit predecessors. */
|
/* Visit all the implicit predecessors. */
|
EXECUTE_IF_IN_NONNULL_BITMAP (graph->implicit_preds[n], 0, i, bi)
|
EXECUTE_IF_IN_NONNULL_BITMAP (graph->implicit_preds[n], 0, i, bi)
|
{
|
{
|
unsigned int w = si->node_mapping[i];
|
unsigned int w = si->node_mapping[i];
|
|
|
if (TEST_BIT (si->roots, w))
|
if (TEST_BIT (si->roots, w))
|
continue;
|
continue;
|
|
|
if (!TEST_BIT (si->visited, w))
|
if (!TEST_BIT (si->visited, w))
|
label_visit (graph, si, w);
|
label_visit (graph, si, w);
|
{
|
{
|
unsigned int t = si->node_mapping[w];
|
unsigned int t = si->node_mapping[w];
|
unsigned int nnode = si->node_mapping[n];
|
unsigned int nnode = si->node_mapping[n];
|
gcc_assert (nnode == n);
|
gcc_assert (nnode == n);
|
|
|
if (si->dfs[t] < si->dfs[nnode])
|
if (si->dfs[t] < si->dfs[nnode])
|
si->dfs[n] = si->dfs[t];
|
si->dfs[n] = si->dfs[t];
|
}
|
}
|
}
|
}
|
|
|
/* See if any components have been identified. */
|
/* See if any components have been identified. */
|
if (si->dfs[n] == my_dfs)
|
if (si->dfs[n] == my_dfs)
|
{
|
{
|
while (VEC_length (unsigned, si->scc_stack) != 0
|
while (VEC_length (unsigned, si->scc_stack) != 0
|
&& si->dfs[VEC_last (unsigned, si->scc_stack)] >= my_dfs)
|
&& si->dfs[VEC_last (unsigned, si->scc_stack)] >= my_dfs)
|
{
|
{
|
unsigned int w = VEC_pop (unsigned, si->scc_stack);
|
unsigned int w = VEC_pop (unsigned, si->scc_stack);
|
si->node_mapping[w] = n;
|
si->node_mapping[w] = n;
|
|
|
if (!TEST_BIT (graph->direct_nodes, w))
|
if (!TEST_BIT (graph->direct_nodes, w))
|
RESET_BIT (graph->direct_nodes, n);
|
RESET_BIT (graph->direct_nodes, n);
|
}
|
}
|
SET_BIT (si->roots, n);
|
SET_BIT (si->roots, n);
|
|
|
if (!TEST_BIT (graph->direct_nodes, n))
|
if (!TEST_BIT (graph->direct_nodes, n))
|
{
|
{
|
graph->label[n] = equivalence_class++;
|
graph->label[n] = equivalence_class++;
|
}
|
}
|
else
|
else
|
{
|
{
|
unsigned int size = 0;
|
unsigned int size = 0;
|
unsigned int firstlabel = ~0;
|
unsigned int firstlabel = ~0;
|
|
|
EXECUTE_IF_IN_NONNULL_BITMAP (graph->preds[n], 0, i, bi)
|
EXECUTE_IF_IN_NONNULL_BITMAP (graph->preds[n], 0, i, bi)
|
{
|
{
|
unsigned int j = si->node_mapping[i];
|
unsigned int j = si->node_mapping[i];
|
|
|
if (j == n || graph->label[j] == 0)
|
if (j == n || graph->label[j] == 0)
|
continue;
|
continue;
|
|
|
if (firstlabel == (unsigned int)~0)
|
if (firstlabel == (unsigned int)~0)
|
{
|
{
|
firstlabel = graph->label[j];
|
firstlabel = graph->label[j];
|
size++;
|
size++;
|
}
|
}
|
else if (graph->label[j] != firstlabel)
|
else if (graph->label[j] != firstlabel)
|
size++;
|
size++;
|
}
|
}
|
|
|
if (size == 0)
|
if (size == 0)
|
graph->label[n] = 0;
|
graph->label[n] = 0;
|
else if (size == 1)
|
else if (size == 1)
|
graph->label[n] = firstlabel;
|
graph->label[n] = firstlabel;
|
else
|
else
|
graph->label[n] = equivalence_class++;
|
graph->label[n] = equivalence_class++;
|
}
|
}
|
}
|
}
|
else
|
else
|
VEC_safe_push (unsigned, heap, si->scc_stack, n);
|
VEC_safe_push (unsigned, heap, si->scc_stack, n);
|
}
|
}
|
|
|
/* Perform offline variable substitution, discovering equivalence
|
/* Perform offline variable substitution, discovering equivalence
|
classes, and eliminating non-pointer variables. */
|
classes, and eliminating non-pointer variables. */
|
|
|
static struct scc_info *
|
static struct scc_info *
|
perform_var_substitution (constraint_graph_t graph)
|
perform_var_substitution (constraint_graph_t graph)
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
unsigned int size = graph->size;
|
unsigned int size = graph->size;
|
struct scc_info *si = init_scc_info (size);
|
struct scc_info *si = init_scc_info (size);
|
|
|
bitmap_obstack_initialize (&iteration_obstack);
|
bitmap_obstack_initialize (&iteration_obstack);
|
equivalence_class = 0;
|
equivalence_class = 0;
|
|
|
/* We only need to visit the non-address nodes for labeling
|
/* We only need to visit the non-address nodes for labeling
|
purposes, as the address nodes will never have any predecessors,
|
purposes, as the address nodes will never have any predecessors,
|
because &x never appears on the LHS of a constraint. */
|
because &x never appears on the LHS of a constraint. */
|
for (i = 0; i < LAST_REF_NODE; i++)
|
for (i = 0; i < LAST_REF_NODE; i++)
|
if (!TEST_BIT (si->visited, si->node_mapping[i]))
|
if (!TEST_BIT (si->visited, si->node_mapping[i]))
|
label_visit (graph, si, si->node_mapping[i]);
|
label_visit (graph, si, si->node_mapping[i]);
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
for (i = 0; i < FIRST_REF_NODE; i++)
|
for (i = 0; i < FIRST_REF_NODE; i++)
|
{
|
{
|
bool direct_node = TEST_BIT (graph->direct_nodes, i);
|
bool direct_node = TEST_BIT (graph->direct_nodes, i);
|
fprintf (dump_file,
|
fprintf (dump_file,
|
"Equivalence class for %s node id %d:%s is %d\n",
|
"Equivalence class for %s node id %d:%s is %d\n",
|
direct_node ? "Direct node" : "Indirect node", i,
|
direct_node ? "Direct node" : "Indirect node", i,
|
get_varinfo (i)->name,
|
get_varinfo (i)->name,
|
graph->label[si->node_mapping[i]]);
|
graph->label[si->node_mapping[i]]);
|
}
|
}
|
|
|
/* Quickly eliminate our non-pointer variables. */
|
/* Quickly eliminate our non-pointer variables. */
|
|
|
for (i = 0; i < FIRST_REF_NODE; i++)
|
for (i = 0; i < FIRST_REF_NODE; i++)
|
{
|
{
|
unsigned int node = si->node_mapping[i];
|
unsigned int node = si->node_mapping[i];
|
|
|
if (graph->label[node] == 0 && TEST_BIT (graph->direct_nodes, node))
|
if (graph->label[node] == 0 && TEST_BIT (graph->direct_nodes, node))
|
{
|
{
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
fprintf (dump_file,
|
fprintf (dump_file,
|
"%s is a non-pointer variable, eliminating edges.\n",
|
"%s is a non-pointer variable, eliminating edges.\n",
|
get_varinfo (node)->name);
|
get_varinfo (node)->name);
|
stats.nonpointer_vars++;
|
stats.nonpointer_vars++;
|
clear_edges_for_node (graph, node);
|
clear_edges_for_node (graph, node);
|
}
|
}
|
}
|
}
|
return si;
|
return si;
|
}
|
}
|
|
|
/* Free information that was only necessary for variable
|
/* Free information that was only necessary for variable
|
substitution. */
|
substitution. */
|
|
|
static void
|
static void
|
free_var_substitution_info (struct scc_info *si)
|
free_var_substitution_info (struct scc_info *si)
|
{
|
{
|
free_scc_info (si);
|
free_scc_info (si);
|
free (graph->label);
|
free (graph->label);
|
free (graph->eq_rep);
|
free (graph->eq_rep);
|
sbitmap_free (graph->direct_nodes);
|
sbitmap_free (graph->direct_nodes);
|
bitmap_obstack_release (&iteration_obstack);
|
bitmap_obstack_release (&iteration_obstack);
|
}
|
}
|
|
|
/* Return an existing node that is equivalent to NODE, which has
|
/* Return an existing node that is equivalent to NODE, which has
|
equivalence class LABEL, if one exists. Return NODE otherwise. */
|
equivalence class LABEL, if one exists. Return NODE otherwise. */
|
|
|
static unsigned int
|
static unsigned int
|
find_equivalent_node (constraint_graph_t graph,
|
find_equivalent_node (constraint_graph_t graph,
|
unsigned int node, unsigned int label)
|
unsigned int node, unsigned int label)
|
{
|
{
|
/* If the address version of this variable is unused, we can
|
/* If the address version of this variable is unused, we can
|
substitute it for anything else with the same label.
|
substitute it for anything else with the same label.
|
Otherwise, we know the pointers are equivalent, but not the
|
Otherwise, we know the pointers are equivalent, but not the
|
locations. */
|
locations. */
|
|
|
if (graph->label[FIRST_ADDR_NODE + node] == 0)
|
if (graph->label[FIRST_ADDR_NODE + node] == 0)
|
{
|
{
|
gcc_assert (label < graph->size);
|
gcc_assert (label < graph->size);
|
|
|
if (graph->eq_rep[label] != -1)
|
if (graph->eq_rep[label] != -1)
|
{
|
{
|
/* Unify the two variables since we know they are equivalent. */
|
/* Unify the two variables since we know they are equivalent. */
|
if (unite (graph->eq_rep[label], node))
|
if (unite (graph->eq_rep[label], node))
|
unify_nodes (graph, graph->eq_rep[label], node, false);
|
unify_nodes (graph, graph->eq_rep[label], node, false);
|
return graph->eq_rep[label];
|
return graph->eq_rep[label];
|
}
|
}
|
else
|
else
|
{
|
{
|
graph->eq_rep[label] = node;
|
graph->eq_rep[label] = node;
|
}
|
}
|
}
|
}
|
return node;
|
return node;
|
}
|
}
|
|
|
/* Move complex constraints to the appropriate nodes, and collapse
|
/* Move complex constraints to the appropriate nodes, and collapse
|
variables we've discovered are equivalent during variable
|
variables we've discovered are equivalent during variable
|
substitution. SI is the SCC_INFO that is the result of
|
substitution. SI is the SCC_INFO that is the result of
|
perform_variable_substitution. */
|
perform_variable_substitution. */
|
|
|
static void
|
static void
|
move_complex_constraints (constraint_graph_t graph,
|
move_complex_constraints (constraint_graph_t graph,
|
struct scc_info *si)
|
struct scc_info *si)
|
{
|
{
|
int i;
|
int i;
|
unsigned int j;
|
unsigned int j;
|
constraint_t c;
|
constraint_t c;
|
|
|
for (j = 0; j < graph->size; j++)
|
for (j = 0; j < graph->size; j++)
|
gcc_assert (find (j) == j);
|
gcc_assert (find (j) == j);
|
|
|
for (i = 0; VEC_iterate (constraint_t, constraints, i, c); i++)
|
for (i = 0; VEC_iterate (constraint_t, constraints, i, c); i++)
|
{
|
{
|
struct constraint_expr lhs = c->lhs;
|
struct constraint_expr lhs = c->lhs;
|
struct constraint_expr rhs = c->rhs;
|
struct constraint_expr rhs = c->rhs;
|
unsigned int lhsvar = find (get_varinfo_fc (lhs.var)->id);
|
unsigned int lhsvar = find (get_varinfo_fc (lhs.var)->id);
|
unsigned int rhsvar = find (get_varinfo_fc (rhs.var)->id);
|
unsigned int rhsvar = find (get_varinfo_fc (rhs.var)->id);
|
unsigned int lhsnode, rhsnode;
|
unsigned int lhsnode, rhsnode;
|
unsigned int lhslabel, rhslabel;
|
unsigned int lhslabel, rhslabel;
|
|
|
lhsnode = si->node_mapping[lhsvar];
|
lhsnode = si->node_mapping[lhsvar];
|
rhsnode = si->node_mapping[rhsvar];
|
rhsnode = si->node_mapping[rhsvar];
|
lhslabel = graph->label[lhsnode];
|
lhslabel = graph->label[lhsnode];
|
rhslabel = graph->label[rhsnode];
|
rhslabel = graph->label[rhsnode];
|
|
|
/* See if it is really a non-pointer variable, and if so, ignore
|
/* See if it is really a non-pointer variable, and if so, ignore
|
the constraint. */
|
the constraint. */
|
if (lhslabel == 0)
|
if (lhslabel == 0)
|
{
|
{
|
if (!TEST_BIT (graph->direct_nodes, lhsnode))
|
if (!TEST_BIT (graph->direct_nodes, lhsnode))
|
lhslabel = graph->label[lhsnode] = equivalence_class++;
|
lhslabel = graph->label[lhsnode] = equivalence_class++;
|
else
|
else
|
{
|
{
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
|
|
fprintf (dump_file, "%s is a non-pointer variable,"
|
fprintf (dump_file, "%s is a non-pointer variable,"
|
"ignoring constraint:",
|
"ignoring constraint:",
|
get_varinfo (lhs.var)->name);
|
get_varinfo (lhs.var)->name);
|
dump_constraint (dump_file, c);
|
dump_constraint (dump_file, c);
|
}
|
}
|
VEC_replace (constraint_t, constraints, i, NULL);
|
VEC_replace (constraint_t, constraints, i, NULL);
|
continue;
|
continue;
|
}
|
}
|
}
|
}
|
|
|
if (rhslabel == 0)
|
if (rhslabel == 0)
|
{
|
{
|
if (!TEST_BIT (graph->direct_nodes, rhsnode))
|
if (!TEST_BIT (graph->direct_nodes, rhsnode))
|
rhslabel = graph->label[rhsnode] = equivalence_class++;
|
rhslabel = graph->label[rhsnode] = equivalence_class++;
|
else
|
else
|
{
|
{
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
|
|
fprintf (dump_file, "%s is a non-pointer variable,"
|
fprintf (dump_file, "%s is a non-pointer variable,"
|
"ignoring constraint:",
|
"ignoring constraint:",
|
get_varinfo (rhs.var)->name);
|
get_varinfo (rhs.var)->name);
|
dump_constraint (dump_file, c);
|
dump_constraint (dump_file, c);
|
}
|
}
|
VEC_replace (constraint_t, constraints, i, NULL);
|
VEC_replace (constraint_t, constraints, i, NULL);
|
continue;
|
continue;
|
}
|
}
|
}
|
}
|
|
|
lhsvar = find_equivalent_node (graph, lhsvar, lhslabel);
|
lhsvar = find_equivalent_node (graph, lhsvar, lhslabel);
|
rhsvar = find_equivalent_node (graph, rhsvar, rhslabel);
|
rhsvar = find_equivalent_node (graph, rhsvar, rhslabel);
|
c->lhs.var = lhsvar;
|
c->lhs.var = lhsvar;
|
c->rhs.var = rhsvar;
|
c->rhs.var = rhsvar;
|
|
|
if (lhs.type == DEREF)
|
if (lhs.type == DEREF)
|
{
|
{
|
if (rhs.type == ADDRESSOF || rhsvar > anything_id)
|
if (rhs.type == ADDRESSOF || rhsvar > anything_id)
|
insert_into_complex (graph, lhsvar, c);
|
insert_into_complex (graph, lhsvar, c);
|
}
|
}
|
else if (rhs.type == DEREF)
|
else if (rhs.type == DEREF)
|
{
|
{
|
if (!(get_varinfo (lhsvar)->is_special_var))
|
if (!(get_varinfo (lhsvar)->is_special_var))
|
insert_into_complex (graph, rhsvar, c);
|
insert_into_complex (graph, rhsvar, c);
|
}
|
}
|
else if (rhs.type != ADDRESSOF && lhsvar > anything_id
|
else if (rhs.type != ADDRESSOF && lhsvar > anything_id
|
&& (lhs.offset != 0 || rhs.offset != 0))
|
&& (lhs.offset != 0 || rhs.offset != 0))
|
{
|
{
|
insert_into_complex (graph, rhsvar, c);
|
insert_into_complex (graph, rhsvar, c);
|
}
|
}
|
|
|
}
|
}
|
}
|
}
|
|
|
/* Eliminate indirect cycles involving NODE. Return true if NODE was
|
/* Eliminate indirect cycles involving NODE. Return true if NODE was
|
part of an SCC, false otherwise. */
|
part of an SCC, false otherwise. */
|
|
|
static bool
|
static bool
|
eliminate_indirect_cycles (unsigned int node)
|
eliminate_indirect_cycles (unsigned int node)
|
{
|
{
|
if (graph->indirect_cycles[node] != -1
|
if (graph->indirect_cycles[node] != -1
|
&& !bitmap_empty_p (get_varinfo (node)->solution))
|
&& !bitmap_empty_p (get_varinfo (node)->solution))
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
VEC(unsigned,heap) *queue = NULL;
|
VEC(unsigned,heap) *queue = NULL;
|
int queuepos;
|
int queuepos;
|
unsigned int to = find (graph->indirect_cycles[node]);
|
unsigned int to = find (graph->indirect_cycles[node]);
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
|
|
/* We can't touch the solution set and call unify_nodes
|
/* We can't touch the solution set and call unify_nodes
|
at the same time, because unify_nodes is going to do
|
at the same time, because unify_nodes is going to do
|
bitmap unions into it. */
|
bitmap unions into it. */
|
|
|
EXECUTE_IF_SET_IN_BITMAP (get_varinfo (node)->solution, 0, i, bi)
|
EXECUTE_IF_SET_IN_BITMAP (get_varinfo (node)->solution, 0, i, bi)
|
{
|
{
|
if (find (i) == i && i != to)
|
if (find (i) == i && i != to)
|
{
|
{
|
if (unite (to, i))
|
if (unite (to, i))
|
VEC_safe_push (unsigned, heap, queue, i);
|
VEC_safe_push (unsigned, heap, queue, i);
|
}
|
}
|
}
|
}
|
|
|
for (queuepos = 0;
|
for (queuepos = 0;
|
VEC_iterate (unsigned, queue, queuepos, i);
|
VEC_iterate (unsigned, queue, queuepos, i);
|
queuepos++)
|
queuepos++)
|
{
|
{
|
unify_nodes (graph, to, i, true);
|
unify_nodes (graph, to, i, true);
|
}
|
}
|
VEC_free (unsigned, heap, queue);
|
VEC_free (unsigned, heap, queue);
|
return true;
|
return true;
|
}
|
}
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Solve the constraint graph GRAPH using our worklist solver.
|
/* Solve the constraint graph GRAPH using our worklist solver.
|
This is based on the PW* family of solvers from the "Efficient Field
|
This is based on the PW* family of solvers from the "Efficient Field
|
Sensitive Pointer Analysis for C" paper.
|
Sensitive Pointer Analysis for C" paper.
|
It works by iterating over all the graph nodes, processing the complex
|
It works by iterating over all the graph nodes, processing the complex
|
constraints and propagating the copy constraints, until everything stops
|
constraints and propagating the copy constraints, until everything stops
|
changed. This corresponds to steps 6-8 in the solving list given above. */
|
changed. This corresponds to steps 6-8 in the solving list given above. */
|
|
|
static void
|
static void
|
solve_graph (constraint_graph_t graph)
|
solve_graph (constraint_graph_t graph)
|
{
|
{
|
unsigned int size = VEC_length (varinfo_t, varmap);
|
unsigned int size = VEC_length (varinfo_t, varmap);
|
unsigned int i;
|
unsigned int i;
|
bitmap pts;
|
bitmap pts;
|
|
|
changed_count = 0;
|
changed_count = 0;
|
changed = sbitmap_alloc (size);
|
changed = sbitmap_alloc (size);
|
sbitmap_zero (changed);
|
sbitmap_zero (changed);
|
|
|
/* Mark all initial non-collapsed nodes as changed. */
|
/* Mark all initial non-collapsed nodes as changed. */
|
for (i = 0; i < size; i++)
|
for (i = 0; i < size; i++)
|
{
|
{
|
varinfo_t ivi = get_varinfo (i);
|
varinfo_t ivi = get_varinfo (i);
|
if (find (i) == i && !bitmap_empty_p (ivi->solution)
|
if (find (i) == i && !bitmap_empty_p (ivi->solution)
|
&& ((graph->succs[i] && !bitmap_empty_p (graph->succs[i]))
|
&& ((graph->succs[i] && !bitmap_empty_p (graph->succs[i]))
|
|| VEC_length (constraint_t, graph->complex[i]) > 0))
|
|| VEC_length (constraint_t, graph->complex[i]) > 0))
|
{
|
{
|
SET_BIT (changed, i);
|
SET_BIT (changed, i);
|
changed_count++;
|
changed_count++;
|
}
|
}
|
}
|
}
|
|
|
/* Allocate a bitmap to be used to store the changed bits. */
|
/* Allocate a bitmap to be used to store the changed bits. */
|
pts = BITMAP_ALLOC (&pta_obstack);
|
pts = BITMAP_ALLOC (&pta_obstack);
|
|
|
while (changed_count > 0)
|
while (changed_count > 0)
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
struct topo_info *ti = init_topo_info ();
|
struct topo_info *ti = init_topo_info ();
|
stats.iterations++;
|
stats.iterations++;
|
|
|
bitmap_obstack_initialize (&iteration_obstack);
|
bitmap_obstack_initialize (&iteration_obstack);
|
|
|
compute_topo_order (graph, ti);
|
compute_topo_order (graph, ti);
|
|
|
while (VEC_length (unsigned, ti->topo_order) != 0)
|
while (VEC_length (unsigned, ti->topo_order) != 0)
|
{
|
{
|
|
|
i = VEC_pop (unsigned, ti->topo_order);
|
i = VEC_pop (unsigned, ti->topo_order);
|
|
|
/* If this variable is not a representative, skip it. */
|
/* If this variable is not a representative, skip it. */
|
if (find (i) != i)
|
if (find (i) != i)
|
continue;
|
continue;
|
|
|
/* In certain indirect cycle cases, we may merge this
|
/* In certain indirect cycle cases, we may merge this
|
variable to another. */
|
variable to another. */
|
if (eliminate_indirect_cycles (i) && find (i) != i)
|
if (eliminate_indirect_cycles (i) && find (i) != i)
|
continue;
|
continue;
|
|
|
/* If the node has changed, we need to process the
|
/* If the node has changed, we need to process the
|
complex constraints and outgoing edges again. */
|
complex constraints and outgoing edges again. */
|
if (TEST_BIT (changed, i))
|
if (TEST_BIT (changed, i))
|
{
|
{
|
unsigned int j;
|
unsigned int j;
|
constraint_t c;
|
constraint_t c;
|
bitmap solution;
|
bitmap solution;
|
VEC(constraint_t,heap) *complex = graph->complex[i];
|
VEC(constraint_t,heap) *complex = graph->complex[i];
|
bool solution_empty;
|
bool solution_empty;
|
|
|
RESET_BIT (changed, i);
|
RESET_BIT (changed, i);
|
changed_count--;
|
changed_count--;
|
|
|
/* Compute the changed set of solution bits. */
|
/* Compute the changed set of solution bits. */
|
bitmap_and_compl (pts, get_varinfo (i)->solution,
|
bitmap_and_compl (pts, get_varinfo (i)->solution,
|
get_varinfo (i)->oldsolution);
|
get_varinfo (i)->oldsolution);
|
|
|
if (bitmap_empty_p (pts))
|
if (bitmap_empty_p (pts))
|
continue;
|
continue;
|
|
|
bitmap_ior_into (get_varinfo (i)->oldsolution, pts);
|
bitmap_ior_into (get_varinfo (i)->oldsolution, pts);
|
|
|
solution = get_varinfo (i)->solution;
|
solution = get_varinfo (i)->solution;
|
solution_empty = bitmap_empty_p (solution);
|
solution_empty = bitmap_empty_p (solution);
|
|
|
/* Process the complex constraints */
|
/* Process the complex constraints */
|
for (j = 0; VEC_iterate (constraint_t, complex, j, c); j++)
|
for (j = 0; VEC_iterate (constraint_t, complex, j, c); j++)
|
{
|
{
|
/* The only complex constraint that can change our
|
/* The only complex constraint that can change our
|
solution to non-empty, given an empty solution,
|
solution to non-empty, given an empty solution,
|
is a constraint where the lhs side is receiving
|
is a constraint where the lhs side is receiving
|
some set from elsewhere. */
|
some set from elsewhere. */
|
if (!solution_empty || c->lhs.type != DEREF)
|
if (!solution_empty || c->lhs.type != DEREF)
|
do_complex_constraint (graph, c, pts);
|
do_complex_constraint (graph, c, pts);
|
}
|
}
|
|
|
solution_empty = bitmap_empty_p (solution);
|
solution_empty = bitmap_empty_p (solution);
|
|
|
if (!solution_empty)
|
if (!solution_empty)
|
{
|
{
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
|
|
/* Propagate solution to all successors. */
|
/* Propagate solution to all successors. */
|
EXECUTE_IF_IN_NONNULL_BITMAP (graph->succs[i],
|
EXECUTE_IF_IN_NONNULL_BITMAP (graph->succs[i],
|
0, j, bi)
|
0, j, bi)
|
{
|
{
|
bitmap tmp;
|
bitmap tmp;
|
bool flag;
|
bool flag;
|
|
|
unsigned int to = find (j);
|
unsigned int to = find (j);
|
tmp = get_varinfo (to)->solution;
|
tmp = get_varinfo (to)->solution;
|
flag = false;
|
flag = false;
|
|
|
/* Don't try to propagate to ourselves. */
|
/* Don't try to propagate to ourselves. */
|
if (to == i)
|
if (to == i)
|
continue;
|
continue;
|
|
|
flag = set_union_with_increment (tmp, pts, 0);
|
flag = set_union_with_increment (tmp, pts, 0);
|
|
|
if (flag)
|
if (flag)
|
{
|
{
|
get_varinfo (to)->solution = tmp;
|
get_varinfo (to)->solution = tmp;
|
if (!TEST_BIT (changed, to))
|
if (!TEST_BIT (changed, to))
|
{
|
{
|
SET_BIT (changed, to);
|
SET_BIT (changed, to);
|
changed_count++;
|
changed_count++;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
free_topo_info (ti);
|
free_topo_info (ti);
|
bitmap_obstack_release (&iteration_obstack);
|
bitmap_obstack_release (&iteration_obstack);
|
}
|
}
|
|
|
BITMAP_FREE (pts);
|
BITMAP_FREE (pts);
|
sbitmap_free (changed);
|
sbitmap_free (changed);
|
bitmap_obstack_release (&oldpta_obstack);
|
bitmap_obstack_release (&oldpta_obstack);
|
}
|
}
|
|
|
/* Map from trees to variable infos. */
|
/* Map from trees to variable infos. */
|
static struct pointer_map_t *vi_for_tree;
|
static struct pointer_map_t *vi_for_tree;
|
|
|
|
|
/* Insert ID as the variable id for tree T in the vi_for_tree map. */
|
/* Insert ID as the variable id for tree T in the vi_for_tree map. */
|
|
|
static void
|
static void
|
insert_vi_for_tree (tree t, varinfo_t vi)
|
insert_vi_for_tree (tree t, varinfo_t vi)
|
{
|
{
|
void **slot = pointer_map_insert (vi_for_tree, t);
|
void **slot = pointer_map_insert (vi_for_tree, t);
|
gcc_assert (vi);
|
gcc_assert (vi);
|
gcc_assert (*slot == NULL);
|
gcc_assert (*slot == NULL);
|
*slot = vi;
|
*slot = vi;
|
}
|
}
|
|
|
/* Find the variable info for tree T in VI_FOR_TREE. If T does not
|
/* Find the variable info for tree T in VI_FOR_TREE. If T does not
|
exist in the map, return NULL, otherwise, return the varinfo we found. */
|
exist in the map, return NULL, otherwise, return the varinfo we found. */
|
|
|
static varinfo_t
|
static varinfo_t
|
lookup_vi_for_tree (tree t)
|
lookup_vi_for_tree (tree t)
|
{
|
{
|
void **slot = pointer_map_contains (vi_for_tree, t);
|
void **slot = pointer_map_contains (vi_for_tree, t);
|
if (slot == NULL)
|
if (slot == NULL)
|
return NULL;
|
return NULL;
|
|
|
return (varinfo_t) *slot;
|
return (varinfo_t) *slot;
|
}
|
}
|
|
|
/* Return a printable name for DECL */
|
/* Return a printable name for DECL */
|
|
|
static const char *
|
static const char *
|
alias_get_name (tree decl)
|
alias_get_name (tree decl)
|
{
|
{
|
const char *res = get_name (decl);
|
const char *res = get_name (decl);
|
char *temp;
|
char *temp;
|
int num_printed = 0;
|
int num_printed = 0;
|
|
|
if (res != NULL)
|
if (res != NULL)
|
return res;
|
return res;
|
|
|
res = "NULL";
|
res = "NULL";
|
if (!dump_file)
|
if (!dump_file)
|
return res;
|
return res;
|
|
|
if (TREE_CODE (decl) == SSA_NAME)
|
if (TREE_CODE (decl) == SSA_NAME)
|
{
|
{
|
num_printed = asprintf (&temp, "%s_%u",
|
num_printed = asprintf (&temp, "%s_%u",
|
alias_get_name (SSA_NAME_VAR (decl)),
|
alias_get_name (SSA_NAME_VAR (decl)),
|
SSA_NAME_VERSION (decl));
|
SSA_NAME_VERSION (decl));
|
}
|
}
|
else if (DECL_P (decl))
|
else if (DECL_P (decl))
|
{
|
{
|
num_printed = asprintf (&temp, "D.%u", DECL_UID (decl));
|
num_printed = asprintf (&temp, "D.%u", DECL_UID (decl));
|
}
|
}
|
if (num_printed > 0)
|
if (num_printed > 0)
|
{
|
{
|
res = ggc_strdup (temp);
|
res = ggc_strdup (temp);
|
free (temp);
|
free (temp);
|
}
|
}
|
return res;
|
return res;
|
}
|
}
|
|
|
/* Find the variable id for tree T in the map.
|
/* Find the variable id for tree T in the map.
|
If T doesn't exist in the map, create an entry for it and return it. */
|
If T doesn't exist in the map, create an entry for it and return it. */
|
|
|
static varinfo_t
|
static varinfo_t
|
get_vi_for_tree (tree t)
|
get_vi_for_tree (tree t)
|
{
|
{
|
void **slot = pointer_map_contains (vi_for_tree, t);
|
void **slot = pointer_map_contains (vi_for_tree, t);
|
if (slot == NULL)
|
if (slot == NULL)
|
return get_varinfo (create_variable_info_for (t, alias_get_name (t)));
|
return get_varinfo (create_variable_info_for (t, alias_get_name (t)));
|
|
|
return (varinfo_t) *slot;
|
return (varinfo_t) *slot;
|
}
|
}
|
|
|
/* Get a constraint expression from an SSA_VAR_P node. */
|
/* Get a constraint expression from an SSA_VAR_P node. */
|
|
|
static struct constraint_expr
|
static struct constraint_expr
|
get_constraint_exp_from_ssa_var (tree t)
|
get_constraint_exp_from_ssa_var (tree t)
|
{
|
{
|
struct constraint_expr cexpr;
|
struct constraint_expr cexpr;
|
|
|
gcc_assert (SSA_VAR_P (t) || DECL_P (t));
|
gcc_assert (SSA_VAR_P (t) || DECL_P (t));
|
|
|
/* For parameters, get at the points-to set for the actual parm
|
/* For parameters, get at the points-to set for the actual parm
|
decl. */
|
decl. */
|
if (TREE_CODE (t) == SSA_NAME
|
if (TREE_CODE (t) == SSA_NAME
|
&& TREE_CODE (SSA_NAME_VAR (t)) == PARM_DECL
|
&& TREE_CODE (SSA_NAME_VAR (t)) == PARM_DECL
|
&& default_def (SSA_NAME_VAR (t)) == t)
|
&& default_def (SSA_NAME_VAR (t)) == t)
|
return get_constraint_exp_from_ssa_var (SSA_NAME_VAR (t));
|
return get_constraint_exp_from_ssa_var (SSA_NAME_VAR (t));
|
|
|
cexpr.type = SCALAR;
|
cexpr.type = SCALAR;
|
|
|
cexpr.var = get_vi_for_tree (t)->id;
|
cexpr.var = get_vi_for_tree (t)->id;
|
/* If we determine the result is "anything", and we know this is readonly,
|
/* If we determine the result is "anything", and we know this is readonly,
|
say it points to readonly memory instead. */
|
say it points to readonly memory instead. */
|
if (cexpr.var == anything_id && TREE_READONLY (t))
|
if (cexpr.var == anything_id && TREE_READONLY (t))
|
{
|
{
|
cexpr.type = ADDRESSOF;
|
cexpr.type = ADDRESSOF;
|
cexpr.var = readonly_id;
|
cexpr.var = readonly_id;
|
}
|
}
|
|
|
cexpr.offset = 0;
|
cexpr.offset = 0;
|
return cexpr;
|
return cexpr;
|
}
|
}
|
|
|
/* Process a completed constraint T, and add it to the constraint
|
/* Process a completed constraint T, and add it to the constraint
|
list. */
|
list. */
|
|
|
static void
|
static void
|
process_constraint (constraint_t t)
|
process_constraint (constraint_t t)
|
{
|
{
|
struct constraint_expr rhs = t->rhs;
|
struct constraint_expr rhs = t->rhs;
|
struct constraint_expr lhs = t->lhs;
|
struct constraint_expr lhs = t->lhs;
|
|
|
gcc_assert (rhs.var < VEC_length (varinfo_t, varmap));
|
gcc_assert (rhs.var < VEC_length (varinfo_t, varmap));
|
gcc_assert (lhs.var < VEC_length (varinfo_t, varmap));
|
gcc_assert (lhs.var < VEC_length (varinfo_t, varmap));
|
|
|
if (lhs.type == DEREF)
|
if (lhs.type == DEREF)
|
get_varinfo (lhs.var)->directly_dereferenced = true;
|
get_varinfo (lhs.var)->directly_dereferenced = true;
|
if (rhs.type == DEREF)
|
if (rhs.type == DEREF)
|
get_varinfo (rhs.var)->directly_dereferenced = true;
|
get_varinfo (rhs.var)->directly_dereferenced = true;
|
|
|
if (!use_field_sensitive)
|
if (!use_field_sensitive)
|
{
|
{
|
t->rhs.offset = 0;
|
t->rhs.offset = 0;
|
t->lhs.offset = 0;
|
t->lhs.offset = 0;
|
}
|
}
|
|
|
/* ANYTHING == ANYTHING is pointless. */
|
/* ANYTHING == ANYTHING is pointless. */
|
if (lhs.var == anything_id && rhs.var == anything_id)
|
if (lhs.var == anything_id && rhs.var == anything_id)
|
return;
|
return;
|
|
|
/* If we have &ANYTHING = something, convert to SOMETHING = &ANYTHING) */
|
/* If we have &ANYTHING = something, convert to SOMETHING = &ANYTHING) */
|
else if (lhs.var == anything_id && lhs.type == ADDRESSOF)
|
else if (lhs.var == anything_id && lhs.type == ADDRESSOF)
|
{
|
{
|
rhs = t->lhs;
|
rhs = t->lhs;
|
t->lhs = t->rhs;
|
t->lhs = t->rhs;
|
t->rhs = rhs;
|
t->rhs = rhs;
|
process_constraint (t);
|
process_constraint (t);
|
}
|
}
|
/* This can happen in our IR with things like n->a = *p */
|
/* This can happen in our IR with things like n->a = *p */
|
else if (rhs.type == DEREF && lhs.type == DEREF && rhs.var != anything_id)
|
else if (rhs.type == DEREF && lhs.type == DEREF && rhs.var != anything_id)
|
{
|
{
|
/* Split into tmp = *rhs, *lhs = tmp */
|
/* Split into tmp = *rhs, *lhs = tmp */
|
tree rhsdecl = get_varinfo (rhs.var)->decl;
|
tree rhsdecl = get_varinfo (rhs.var)->decl;
|
tree pointertype = TREE_TYPE (rhsdecl);
|
tree pointertype = TREE_TYPE (rhsdecl);
|
tree pointedtotype = TREE_TYPE (pointertype);
|
tree pointedtotype = TREE_TYPE (pointertype);
|
tree tmpvar = create_tmp_var_raw (pointedtotype, "doubledereftmp");
|
tree tmpvar = create_tmp_var_raw (pointedtotype, "doubledereftmp");
|
struct constraint_expr tmplhs = get_constraint_exp_from_ssa_var (tmpvar);
|
struct constraint_expr tmplhs = get_constraint_exp_from_ssa_var (tmpvar);
|
|
|
/* If this is an aggregate of known size, we should have passed
|
/* If this is an aggregate of known size, we should have passed
|
this off to do_structure_copy, and it should have broken it
|
this off to do_structure_copy, and it should have broken it
|
up. */
|
up. */
|
gcc_assert (!AGGREGATE_TYPE_P (pointedtotype)
|
gcc_assert (!AGGREGATE_TYPE_P (pointedtotype)
|
|| get_varinfo (rhs.var)->is_unknown_size_var);
|
|| get_varinfo (rhs.var)->is_unknown_size_var);
|
|
|
process_constraint (new_constraint (tmplhs, rhs));
|
process_constraint (new_constraint (tmplhs, rhs));
|
process_constraint (new_constraint (lhs, tmplhs));
|
process_constraint (new_constraint (lhs, tmplhs));
|
}
|
}
|
else
|
else
|
{
|
{
|
gcc_assert (rhs.type != ADDRESSOF || rhs.offset == 0);
|
gcc_assert (rhs.type != ADDRESSOF || rhs.offset == 0);
|
VEC_safe_push (constraint_t, heap, constraints, t);
|
VEC_safe_push (constraint_t, heap, constraints, t);
|
}
|
}
|
}
|
}
|
|
|
/* Return true if T is a variable of a type that could contain
|
/* Return true if T is a variable of a type that could contain
|
pointers. */
|
pointers. */
|
|
|
static bool
|
static bool
|
could_have_pointers (tree t)
|
could_have_pointers (tree t)
|
{
|
{
|
tree type = TREE_TYPE (t);
|
tree type = TREE_TYPE (t);
|
|
|
if (POINTER_TYPE_P (type)
|
if (POINTER_TYPE_P (type)
|
|| AGGREGATE_TYPE_P (type)
|
|| AGGREGATE_TYPE_P (type)
|
|| TREE_CODE (type) == COMPLEX_TYPE)
|
|| TREE_CODE (type) == COMPLEX_TYPE)
|
return true;
|
return true;
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Return the position, in bits, of FIELD_DECL from the beginning of its
|
/* Return the position, in bits, of FIELD_DECL from the beginning of its
|
structure. */
|
structure. */
|
|
|
static unsigned HOST_WIDE_INT
|
static unsigned HOST_WIDE_INT
|
bitpos_of_field (const tree fdecl)
|
bitpos_of_field (const tree fdecl)
|
{
|
{
|
|
|
if (TREE_CODE (DECL_FIELD_OFFSET (fdecl)) != INTEGER_CST
|
if (TREE_CODE (DECL_FIELD_OFFSET (fdecl)) != INTEGER_CST
|
|| TREE_CODE (DECL_FIELD_BIT_OFFSET (fdecl)) != INTEGER_CST)
|
|| TREE_CODE (DECL_FIELD_BIT_OFFSET (fdecl)) != INTEGER_CST)
|
return -1;
|
return -1;
|
|
|
return (tree_low_cst (DECL_FIELD_OFFSET (fdecl), 1) * 8)
|
return (tree_low_cst (DECL_FIELD_OFFSET (fdecl), 1) * 8)
|
+ tree_low_cst (DECL_FIELD_BIT_OFFSET (fdecl), 1);
|
+ tree_low_cst (DECL_FIELD_BIT_OFFSET (fdecl), 1);
|
}
|
}
|
|
|
|
|
/* Return true if an access to [ACCESSPOS, ACCESSSIZE]
|
/* Return true if an access to [ACCESSPOS, ACCESSSIZE]
|
overlaps with a field at [FIELDPOS, FIELDSIZE] */
|
overlaps with a field at [FIELDPOS, FIELDSIZE] */
|
|
|
static bool
|
static bool
|
offset_overlaps_with_access (const unsigned HOST_WIDE_INT fieldpos,
|
offset_overlaps_with_access (const unsigned HOST_WIDE_INT fieldpos,
|
const unsigned HOST_WIDE_INT fieldsize,
|
const unsigned HOST_WIDE_INT fieldsize,
|
const unsigned HOST_WIDE_INT accesspos,
|
const unsigned HOST_WIDE_INT accesspos,
|
const unsigned HOST_WIDE_INT accesssize)
|
const unsigned HOST_WIDE_INT accesssize)
|
{
|
{
|
if (fieldpos == accesspos && fieldsize == accesssize)
|
if (fieldpos == accesspos && fieldsize == accesssize)
|
return true;
|
return true;
|
if (accesspos >= fieldpos && accesspos < (fieldpos + fieldsize))
|
if (accesspos >= fieldpos && accesspos < (fieldpos + fieldsize))
|
return true;
|
return true;
|
if (accesspos < fieldpos && (accesspos + accesssize > fieldpos))
|
if (accesspos < fieldpos && (accesspos + accesssize > fieldpos))
|
return true;
|
return true;
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Given a COMPONENT_REF T, return the constraint_expr for it. */
|
/* Given a COMPONENT_REF T, return the constraint_expr for it. */
|
|
|
static void
|
static void
|
get_constraint_for_component_ref (tree t, VEC(ce_s, heap) **results)
|
get_constraint_for_component_ref (tree t, VEC(ce_s, heap) **results)
|
{
|
{
|
tree orig_t = t;
|
tree orig_t = t;
|
HOST_WIDE_INT bitsize = -1;
|
HOST_WIDE_INT bitsize = -1;
|
HOST_WIDE_INT bitmaxsize = -1;
|
HOST_WIDE_INT bitmaxsize = -1;
|
HOST_WIDE_INT bitpos;
|
HOST_WIDE_INT bitpos;
|
tree forzero;
|
tree forzero;
|
struct constraint_expr *result;
|
struct constraint_expr *result;
|
unsigned int beforelength = VEC_length (ce_s, *results);
|
unsigned int beforelength = VEC_length (ce_s, *results);
|
|
|
/* Some people like to do cute things like take the address of
|
/* Some people like to do cute things like take the address of
|
&0->a.b */
|
&0->a.b */
|
forzero = t;
|
forzero = t;
|
while (!SSA_VAR_P (forzero) && !CONSTANT_CLASS_P (forzero))
|
while (!SSA_VAR_P (forzero) && !CONSTANT_CLASS_P (forzero))
|
forzero = TREE_OPERAND (forzero, 0);
|
forzero = TREE_OPERAND (forzero, 0);
|
|
|
if (CONSTANT_CLASS_P (forzero) && integer_zerop (forzero))
|
if (CONSTANT_CLASS_P (forzero) && integer_zerop (forzero))
|
{
|
{
|
struct constraint_expr temp;
|
struct constraint_expr temp;
|
|
|
temp.offset = 0;
|
temp.offset = 0;
|
temp.var = integer_id;
|
temp.var = integer_id;
|
temp.type = SCALAR;
|
temp.type = SCALAR;
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
return;
|
return;
|
}
|
}
|
|
|
t = get_ref_base_and_extent (t, &bitpos, &bitsize, &bitmaxsize);
|
t = get_ref_base_and_extent (t, &bitpos, &bitsize, &bitmaxsize);
|
|
|
/* String constants are readonly, so there is nothing to really do
|
/* String constants are readonly, so there is nothing to really do
|
here. */
|
here. */
|
if (TREE_CODE (t) == STRING_CST)
|
if (TREE_CODE (t) == STRING_CST)
|
return;
|
return;
|
|
|
get_constraint_for (t, results);
|
get_constraint_for (t, results);
|
result = VEC_last (ce_s, *results);
|
result = VEC_last (ce_s, *results);
|
result->offset = bitpos;
|
result->offset = bitpos;
|
|
|
gcc_assert (beforelength + 1 == VEC_length (ce_s, *results));
|
gcc_assert (beforelength + 1 == VEC_length (ce_s, *results));
|
|
|
/* This can also happen due to weird offsetof type macros. */
|
/* This can also happen due to weird offsetof type macros. */
|
if (TREE_CODE (t) != ADDR_EXPR && result->type == ADDRESSOF)
|
if (TREE_CODE (t) != ADDR_EXPR && result->type == ADDRESSOF)
|
result->type = SCALAR;
|
result->type = SCALAR;
|
|
|
if (result->type == SCALAR)
|
if (result->type == SCALAR)
|
{
|
{
|
/* In languages like C, you can access one past the end of an
|
/* In languages like C, you can access one past the end of an
|
array. You aren't allowed to dereference it, so we can
|
array. You aren't allowed to dereference it, so we can
|
ignore this constraint. When we handle pointer subtraction,
|
ignore this constraint. When we handle pointer subtraction,
|
we may have to do something cute here. */
|
we may have to do something cute here. */
|
|
|
if (result->offset < get_varinfo (result->var)->fullsize
|
if (result->offset < get_varinfo (result->var)->fullsize
|
&& bitmaxsize != 0)
|
&& bitmaxsize != 0)
|
{
|
{
|
/* It's also not true that the constraint will actually start at the
|
/* It's also not true that the constraint will actually start at the
|
right offset, it may start in some padding. We only care about
|
right offset, it may start in some padding. We only care about
|
setting the constraint to the first actual field it touches, so
|
setting the constraint to the first actual field it touches, so
|
walk to find it. */
|
walk to find it. */
|
varinfo_t curr;
|
varinfo_t curr;
|
for (curr = get_varinfo (result->var); curr; curr = curr->next)
|
for (curr = get_varinfo (result->var); curr; curr = curr->next)
|
{
|
{
|
if (offset_overlaps_with_access (curr->offset, curr->size,
|
if (offset_overlaps_with_access (curr->offset, curr->size,
|
result->offset, bitmaxsize))
|
result->offset, bitmaxsize))
|
{
|
{
|
result->var = curr->id;
|
result->var = curr->id;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
/* assert that we found *some* field there. The user couldn't be
|
/* assert that we found *some* field there. The user couldn't be
|
accessing *only* padding. */
|
accessing *only* padding. */
|
/* Still the user could access one past the end of an array
|
/* Still the user could access one past the end of an array
|
embedded in a struct resulting in accessing *only* padding. */
|
embedded in a struct resulting in accessing *only* padding. */
|
gcc_assert (curr || TREE_CODE (TREE_TYPE (orig_t)) == ARRAY_TYPE
|
gcc_assert (curr || TREE_CODE (TREE_TYPE (orig_t)) == ARRAY_TYPE
|
|| ref_contains_array_ref (orig_t));
|
|| ref_contains_array_ref (orig_t));
|
}
|
}
|
else if (bitmaxsize == 0)
|
else if (bitmaxsize == 0)
|
{
|
{
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
fprintf (dump_file, "Access to zero-sized part of variable,"
|
fprintf (dump_file, "Access to zero-sized part of variable,"
|
"ignoring\n");
|
"ignoring\n");
|
}
|
}
|
else
|
else
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
fprintf (dump_file, "Access to past the end of variable, ignoring\n");
|
fprintf (dump_file, "Access to past the end of variable, ignoring\n");
|
|
|
result->offset = 0;
|
result->offset = 0;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Dereference the constraint expression CONS, and return the result.
|
/* Dereference the constraint expression CONS, and return the result.
|
DEREF (ADDRESSOF) = SCALAR
|
DEREF (ADDRESSOF) = SCALAR
|
DEREF (SCALAR) = DEREF
|
DEREF (SCALAR) = DEREF
|
DEREF (DEREF) = (temp = DEREF1; result = DEREF(temp))
|
DEREF (DEREF) = (temp = DEREF1; result = DEREF(temp))
|
This is needed so that we can handle dereferencing DEREF constraints. */
|
This is needed so that we can handle dereferencing DEREF constraints. */
|
|
|
static void
|
static void
|
do_deref (VEC (ce_s, heap) **constraints)
|
do_deref (VEC (ce_s, heap) **constraints)
|
{
|
{
|
struct constraint_expr *c;
|
struct constraint_expr *c;
|
unsigned int i = 0;
|
unsigned int i = 0;
|
|
|
for (i = 0; VEC_iterate (ce_s, *constraints, i, c); i++)
|
for (i = 0; VEC_iterate (ce_s, *constraints, i, c); i++)
|
{
|
{
|
if (c->type == SCALAR)
|
if (c->type == SCALAR)
|
c->type = DEREF;
|
c->type = DEREF;
|
else if (c->type == ADDRESSOF)
|
else if (c->type == ADDRESSOF)
|
c->type = SCALAR;
|
c->type = SCALAR;
|
else if (c->type == DEREF)
|
else if (c->type == DEREF)
|
{
|
{
|
tree tmpvar = create_tmp_var_raw (ptr_type_node, "dereftmp");
|
tree tmpvar = create_tmp_var_raw (ptr_type_node, "dereftmp");
|
struct constraint_expr tmplhs = get_constraint_exp_from_ssa_var (tmpvar);
|
struct constraint_expr tmplhs = get_constraint_exp_from_ssa_var (tmpvar);
|
process_constraint (new_constraint (tmplhs, *c));
|
process_constraint (new_constraint (tmplhs, *c));
|
c->var = tmplhs.var;
|
c->var = tmplhs.var;
|
}
|
}
|
else
|
else
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
/* Create a nonlocal variable of TYPE to represent nonlocals we can
|
/* Create a nonlocal variable of TYPE to represent nonlocals we can
|
alias. */
|
alias. */
|
|
|
static tree
|
static tree
|
create_nonlocal_var (tree type)
|
create_nonlocal_var (tree type)
|
{
|
{
|
tree nonlocal = create_tmp_var_raw (type, "NONLOCAL");
|
tree nonlocal = create_tmp_var_raw (type, "NONLOCAL");
|
|
|
if (referenced_vars)
|
if (referenced_vars)
|
add_referenced_var (nonlocal);
|
add_referenced_var (nonlocal);
|
|
|
DECL_EXTERNAL (nonlocal) = 1;
|
DECL_EXTERNAL (nonlocal) = 1;
|
return nonlocal;
|
return nonlocal;
|
}
|
}
|
|
|
/* Given a tree T, return the constraint expression for it. */
|
/* Given a tree T, return the constraint expression for it. */
|
|
|
static void
|
static void
|
get_constraint_for (tree t, VEC (ce_s, heap) **results)
|
get_constraint_for (tree t, VEC (ce_s, heap) **results)
|
{
|
{
|
struct constraint_expr temp;
|
struct constraint_expr temp;
|
|
|
/* x = integer is all glommed to a single variable, which doesn't
|
/* x = integer is all glommed to a single variable, which doesn't
|
point to anything by itself. That is, of course, unless it is an
|
point to anything by itself. That is, of course, unless it is an
|
integer constant being treated as a pointer, in which case, we
|
integer constant being treated as a pointer, in which case, we
|
will return that this is really the addressof anything. This
|
will return that this is really the addressof anything. This
|
happens below, since it will fall into the default case. The only
|
happens below, since it will fall into the default case. The only
|
case we know something about an integer treated like a pointer is
|
case we know something about an integer treated like a pointer is
|
when it is the NULL pointer, and then we just say it points to
|
when it is the NULL pointer, and then we just say it points to
|
NULL. */
|
NULL. */
|
if (TREE_CODE (t) == INTEGER_CST
|
if (TREE_CODE (t) == INTEGER_CST
|
&& !POINTER_TYPE_P (TREE_TYPE (t)))
|
&& !POINTER_TYPE_P (TREE_TYPE (t)))
|
{
|
{
|
temp.var = integer_id;
|
temp.var = integer_id;
|
temp.type = SCALAR;
|
temp.type = SCALAR;
|
temp.offset = 0;
|
temp.offset = 0;
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
return;
|
return;
|
}
|
}
|
else if (TREE_CODE (t) == INTEGER_CST
|
else if (TREE_CODE (t) == INTEGER_CST
|
&& integer_zerop (t))
|
&& integer_zerop (t))
|
{
|
{
|
temp.var = nothing_id;
|
temp.var = nothing_id;
|
temp.type = ADDRESSOF;
|
temp.type = ADDRESSOF;
|
temp.offset = 0;
|
temp.offset = 0;
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
return;
|
return;
|
}
|
}
|
|
|
switch (TREE_CODE_CLASS (TREE_CODE (t)))
|
switch (TREE_CODE_CLASS (TREE_CODE (t)))
|
{
|
{
|
case tcc_expression:
|
case tcc_expression:
|
{
|
{
|
switch (TREE_CODE (t))
|
switch (TREE_CODE (t))
|
{
|
{
|
case ADDR_EXPR:
|
case ADDR_EXPR:
|
{
|
{
|
struct constraint_expr *c;
|
struct constraint_expr *c;
|
unsigned int i;
|
unsigned int i;
|
tree exp = TREE_OPERAND (t, 0);
|
tree exp = TREE_OPERAND (t, 0);
|
tree pttype = TREE_TYPE (TREE_TYPE (t));
|
tree pttype = TREE_TYPE (TREE_TYPE (t));
|
|
|
get_constraint_for (exp, results);
|
get_constraint_for (exp, results);
|
|
|
/* Make sure we capture constraints to all elements
|
/* Make sure we capture constraints to all elements
|
of an array. */
|
of an array. */
|
if ((handled_component_p (exp)
|
if ((handled_component_p (exp)
|
&& ref_contains_array_ref (exp))
|
&& ref_contains_array_ref (exp))
|
|| TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
|
|| TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
|
{
|
{
|
struct constraint_expr *origrhs;
|
struct constraint_expr *origrhs;
|
varinfo_t origvar;
|
varinfo_t origvar;
|
struct constraint_expr tmp;
|
struct constraint_expr tmp;
|
|
|
if (VEC_length (ce_s, *results) == 0)
|
if (VEC_length (ce_s, *results) == 0)
|
return;
|
return;
|
|
|
gcc_assert (VEC_length (ce_s, *results) == 1);
|
gcc_assert (VEC_length (ce_s, *results) == 1);
|
origrhs = VEC_last (ce_s, *results);
|
origrhs = VEC_last (ce_s, *results);
|
tmp = *origrhs;
|
tmp = *origrhs;
|
VEC_pop (ce_s, *results);
|
VEC_pop (ce_s, *results);
|
origvar = get_varinfo (origrhs->var);
|
origvar = get_varinfo (origrhs->var);
|
for (; origvar; origvar = origvar->next)
|
for (; origvar; origvar = origvar->next)
|
{
|
{
|
tmp.var = origvar->id;
|
tmp.var = origvar->id;
|
VEC_safe_push (ce_s, heap, *results, &tmp);
|
VEC_safe_push (ce_s, heap, *results, &tmp);
|
}
|
}
|
}
|
}
|
else if (VEC_length (ce_s, *results) == 1
|
else if (VEC_length (ce_s, *results) == 1
|
&& (AGGREGATE_TYPE_P (pttype)
|
&& (AGGREGATE_TYPE_P (pttype)
|
|| TREE_CODE (pttype) == COMPLEX_TYPE))
|
|| TREE_CODE (pttype) == COMPLEX_TYPE))
|
{
|
{
|
struct constraint_expr *origrhs;
|
struct constraint_expr *origrhs;
|
varinfo_t origvar;
|
varinfo_t origvar;
|
struct constraint_expr tmp;
|
struct constraint_expr tmp;
|
|
|
gcc_assert (VEC_length (ce_s, *results) == 1);
|
gcc_assert (VEC_length (ce_s, *results) == 1);
|
origrhs = VEC_last (ce_s, *results);
|
origrhs = VEC_last (ce_s, *results);
|
tmp = *origrhs;
|
tmp = *origrhs;
|
VEC_pop (ce_s, *results);
|
VEC_pop (ce_s, *results);
|
origvar = get_varinfo (origrhs->var);
|
origvar = get_varinfo (origrhs->var);
|
for (; origvar; origvar = origvar->next)
|
for (; origvar; origvar = origvar->next)
|
{
|
{
|
tmp.var = origvar->id;
|
tmp.var = origvar->id;
|
VEC_safe_push (ce_s, heap, *results, &tmp);
|
VEC_safe_push (ce_s, heap, *results, &tmp);
|
}
|
}
|
}
|
}
|
|
|
for (i = 0; VEC_iterate (ce_s, *results, i, c); i++)
|
for (i = 0; VEC_iterate (ce_s, *results, i, c); i++)
|
{
|
{
|
if (c->type == DEREF)
|
if (c->type == DEREF)
|
c->type = SCALAR;
|
c->type = SCALAR;
|
else
|
else
|
c->type = ADDRESSOF;
|
c->type = ADDRESSOF;
|
}
|
}
|
return;
|
return;
|
}
|
}
|
break;
|
break;
|
case CALL_EXPR:
|
case CALL_EXPR:
|
/* XXX: In interprocedural mode, if we didn't have the
|
/* XXX: In interprocedural mode, if we didn't have the
|
body, we would need to do *each pointer argument =
|
body, we would need to do *each pointer argument =
|
&ANYTHING added. */
|
&ANYTHING added. */
|
if (call_expr_flags (t) & (ECF_MALLOC | ECF_MAY_BE_ALLOCA))
|
if (call_expr_flags (t) & (ECF_MALLOC | ECF_MAY_BE_ALLOCA))
|
{
|
{
|
varinfo_t vi;
|
varinfo_t vi;
|
tree heapvar = heapvar_lookup (t);
|
tree heapvar = heapvar_lookup (t);
|
|
|
if (heapvar == NULL)
|
if (heapvar == NULL)
|
{
|
{
|
heapvar = create_tmp_var_raw (ptr_type_node, "HEAP");
|
heapvar = create_tmp_var_raw (ptr_type_node, "HEAP");
|
DECL_EXTERNAL (heapvar) = 1;
|
DECL_EXTERNAL (heapvar) = 1;
|
if (referenced_vars)
|
if (referenced_vars)
|
add_referenced_var (heapvar);
|
add_referenced_var (heapvar);
|
heapvar_insert (t, heapvar);
|
heapvar_insert (t, heapvar);
|
}
|
}
|
|
|
temp.var = create_variable_info_for (heapvar,
|
temp.var = create_variable_info_for (heapvar,
|
alias_get_name (heapvar));
|
alias_get_name (heapvar));
|
|
|
vi = get_varinfo (temp.var);
|
vi = get_varinfo (temp.var);
|
vi->is_artificial_var = 1;
|
vi->is_artificial_var = 1;
|
vi->is_heap_var = 1;
|
vi->is_heap_var = 1;
|
temp.type = ADDRESSOF;
|
temp.type = ADDRESSOF;
|
temp.offset = 0;
|
temp.offset = 0;
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
return;
|
return;
|
}
|
}
|
else
|
else
|
{
|
{
|
temp.var = escaped_vars_id;
|
temp.var = escaped_vars_id;
|
temp.type = SCALAR;
|
temp.type = SCALAR;
|
temp.offset = 0;
|
temp.offset = 0;
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
return;
|
return;
|
}
|
}
|
break;
|
break;
|
default:
|
default:
|
{
|
{
|
temp.type = ADDRESSOF;
|
temp.type = ADDRESSOF;
|
temp.var = anything_id;
|
temp.var = anything_id;
|
temp.offset = 0;
|
temp.offset = 0;
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
}
|
}
|
case tcc_reference:
|
case tcc_reference:
|
{
|
{
|
switch (TREE_CODE (t))
|
switch (TREE_CODE (t))
|
{
|
{
|
case INDIRECT_REF:
|
case INDIRECT_REF:
|
{
|
{
|
get_constraint_for (TREE_OPERAND (t, 0), results);
|
get_constraint_for (TREE_OPERAND (t, 0), results);
|
do_deref (results);
|
do_deref (results);
|
return;
|
return;
|
}
|
}
|
case ARRAY_REF:
|
case ARRAY_REF:
|
case ARRAY_RANGE_REF:
|
case ARRAY_RANGE_REF:
|
case COMPONENT_REF:
|
case COMPONENT_REF:
|
get_constraint_for_component_ref (t, results);
|
get_constraint_for_component_ref (t, results);
|
return;
|
return;
|
default:
|
default:
|
{
|
{
|
temp.type = ADDRESSOF;
|
temp.type = ADDRESSOF;
|
temp.var = anything_id;
|
temp.var = anything_id;
|
temp.offset = 0;
|
temp.offset = 0;
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
}
|
}
|
case tcc_unary:
|
case tcc_unary:
|
{
|
{
|
switch (TREE_CODE (t))
|
switch (TREE_CODE (t))
|
{
|
{
|
case NOP_EXPR:
|
case NOP_EXPR:
|
case CONVERT_EXPR:
|
case CONVERT_EXPR:
|
case NON_LVALUE_EXPR:
|
case NON_LVALUE_EXPR:
|
{
|
{
|
tree op = TREE_OPERAND (t, 0);
|
tree op = TREE_OPERAND (t, 0);
|
|
|
/* Cast from non-pointer to pointers are bad news for us.
|
/* Cast from non-pointer to pointers are bad news for us.
|
Anything else, we see through */
|
Anything else, we see through */
|
if (!(POINTER_TYPE_P (TREE_TYPE (t))
|
if (!(POINTER_TYPE_P (TREE_TYPE (t))
|
&& ! POINTER_TYPE_P (TREE_TYPE (op))))
|
&& ! POINTER_TYPE_P (TREE_TYPE (op))))
|
{
|
{
|
get_constraint_for (op, results);
|
get_constraint_for (op, results);
|
return;
|
return;
|
}
|
}
|
|
|
/* FALLTHRU */
|
/* FALLTHRU */
|
}
|
}
|
default:
|
default:
|
{
|
{
|
temp.type = ADDRESSOF;
|
temp.type = ADDRESSOF;
|
temp.var = anything_id;
|
temp.var = anything_id;
|
temp.offset = 0;
|
temp.offset = 0;
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
}
|
}
|
case tcc_exceptional:
|
case tcc_exceptional:
|
{
|
{
|
switch (TREE_CODE (t))
|
switch (TREE_CODE (t))
|
{
|
{
|
case PHI_NODE:
|
case PHI_NODE:
|
{
|
{
|
get_constraint_for (PHI_RESULT (t), results);
|
get_constraint_for (PHI_RESULT (t), results);
|
return;
|
return;
|
}
|
}
|
break;
|
break;
|
case SSA_NAME:
|
case SSA_NAME:
|
{
|
{
|
struct constraint_expr temp;
|
struct constraint_expr temp;
|
temp = get_constraint_exp_from_ssa_var (t);
|
temp = get_constraint_exp_from_ssa_var (t);
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
return;
|
return;
|
}
|
}
|
break;
|
break;
|
default:
|
default:
|
{
|
{
|
temp.type = ADDRESSOF;
|
temp.type = ADDRESSOF;
|
temp.var = anything_id;
|
temp.var = anything_id;
|
temp.offset = 0;
|
temp.offset = 0;
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
}
|
}
|
case tcc_declaration:
|
case tcc_declaration:
|
{
|
{
|
struct constraint_expr temp;
|
struct constraint_expr temp;
|
temp = get_constraint_exp_from_ssa_var (t);
|
temp = get_constraint_exp_from_ssa_var (t);
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
return;
|
return;
|
}
|
}
|
default:
|
default:
|
{
|
{
|
temp.type = ADDRESSOF;
|
temp.type = ADDRESSOF;
|
temp.var = anything_id;
|
temp.var = anything_id;
|
temp.offset = 0;
|
temp.offset = 0;
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
VEC_safe_push (ce_s, heap, *results, &temp);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Handle the structure copy case where we have a simple structure copy
|
/* Handle the structure copy case where we have a simple structure copy
|
between LHS and RHS that is of SIZE (in bits)
|
between LHS and RHS that is of SIZE (in bits)
|
|
|
For each field of the lhs variable (lhsfield)
|
For each field of the lhs variable (lhsfield)
|
For each field of the rhs variable at lhsfield.offset (rhsfield)
|
For each field of the rhs variable at lhsfield.offset (rhsfield)
|
add the constraint lhsfield = rhsfield
|
add the constraint lhsfield = rhsfield
|
|
|
If we fail due to some kind of type unsafety or other thing we
|
If we fail due to some kind of type unsafety or other thing we
|
can't handle, return false. We expect the caller to collapse the
|
can't handle, return false. We expect the caller to collapse the
|
variable in that case. */
|
variable in that case. */
|
|
|
static bool
|
static bool
|
do_simple_structure_copy (const struct constraint_expr lhs,
|
do_simple_structure_copy (const struct constraint_expr lhs,
|
const struct constraint_expr rhs,
|
const struct constraint_expr rhs,
|
const unsigned HOST_WIDE_INT size)
|
const unsigned HOST_WIDE_INT size)
|
{
|
{
|
varinfo_t p = get_varinfo (lhs.var);
|
varinfo_t p = get_varinfo (lhs.var);
|
unsigned HOST_WIDE_INT pstart, last;
|
unsigned HOST_WIDE_INT pstart, last;
|
pstart = p->offset;
|
pstart = p->offset;
|
last = p->offset + size;
|
last = p->offset + size;
|
for (; p && p->offset < last; p = p->next)
|
for (; p && p->offset < last; p = p->next)
|
{
|
{
|
varinfo_t q;
|
varinfo_t q;
|
struct constraint_expr templhs = lhs;
|
struct constraint_expr templhs = lhs;
|
struct constraint_expr temprhs = rhs;
|
struct constraint_expr temprhs = rhs;
|
unsigned HOST_WIDE_INT fieldoffset;
|
unsigned HOST_WIDE_INT fieldoffset;
|
|
|
templhs.var = p->id;
|
templhs.var = p->id;
|
q = get_varinfo (temprhs.var);
|
q = get_varinfo (temprhs.var);
|
fieldoffset = p->offset - pstart;
|
fieldoffset = p->offset - pstart;
|
q = first_vi_for_offset (q, q->offset + fieldoffset);
|
q = first_vi_for_offset (q, q->offset + fieldoffset);
|
if (!q)
|
if (!q)
|
return false;
|
return false;
|
temprhs.var = q->id;
|
temprhs.var = q->id;
|
process_constraint (new_constraint (templhs, temprhs));
|
process_constraint (new_constraint (templhs, temprhs));
|
}
|
}
|
return true;
|
return true;
|
}
|
}
|
|
|
|
|
/* Handle the structure copy case where we have a structure copy between a
|
/* Handle the structure copy case where we have a structure copy between a
|
aggregate on the LHS and a dereference of a pointer on the RHS
|
aggregate on the LHS and a dereference of a pointer on the RHS
|
that is of SIZE (in bits)
|
that is of SIZE (in bits)
|
|
|
For each field of the lhs variable (lhsfield)
|
For each field of the lhs variable (lhsfield)
|
rhs.offset = lhsfield->offset
|
rhs.offset = lhsfield->offset
|
add the constraint lhsfield = rhs
|
add the constraint lhsfield = rhs
|
*/
|
*/
|
|
|
static void
|
static void
|
do_rhs_deref_structure_copy (const struct constraint_expr lhs,
|
do_rhs_deref_structure_copy (const struct constraint_expr lhs,
|
const struct constraint_expr rhs,
|
const struct constraint_expr rhs,
|
const unsigned HOST_WIDE_INT size)
|
const unsigned HOST_WIDE_INT size)
|
{
|
{
|
varinfo_t p = get_varinfo (lhs.var);
|
varinfo_t p = get_varinfo (lhs.var);
|
unsigned HOST_WIDE_INT pstart,last;
|
unsigned HOST_WIDE_INT pstart,last;
|
pstart = p->offset;
|
pstart = p->offset;
|
last = p->offset + size;
|
last = p->offset + size;
|
|
|
for (; p && p->offset < last; p = p->next)
|
for (; p && p->offset < last; p = p->next)
|
{
|
{
|
varinfo_t q;
|
varinfo_t q;
|
struct constraint_expr templhs = lhs;
|
struct constraint_expr templhs = lhs;
|
struct constraint_expr temprhs = rhs;
|
struct constraint_expr temprhs = rhs;
|
unsigned HOST_WIDE_INT fieldoffset;
|
unsigned HOST_WIDE_INT fieldoffset;
|
|
|
|
|
if (templhs.type == SCALAR)
|
if (templhs.type == SCALAR)
|
templhs.var = p->id;
|
templhs.var = p->id;
|
else
|
else
|
templhs.offset = p->offset;
|
templhs.offset = p->offset;
|
|
|
q = get_varinfo (temprhs.var);
|
q = get_varinfo (temprhs.var);
|
fieldoffset = p->offset - pstart;
|
fieldoffset = p->offset - pstart;
|
temprhs.offset += fieldoffset;
|
temprhs.offset += fieldoffset;
|
process_constraint (new_constraint (templhs, temprhs));
|
process_constraint (new_constraint (templhs, temprhs));
|
}
|
}
|
}
|
}
|
|
|
/* Handle the structure copy case where we have a structure copy
|
/* Handle the structure copy case where we have a structure copy
|
between a aggregate on the RHS and a dereference of a pointer on
|
between a aggregate on the RHS and a dereference of a pointer on
|
the LHS that is of SIZE (in bits)
|
the LHS that is of SIZE (in bits)
|
|
|
For each field of the rhs variable (rhsfield)
|
For each field of the rhs variable (rhsfield)
|
lhs.offset = rhsfield->offset
|
lhs.offset = rhsfield->offset
|
add the constraint lhs = rhsfield
|
add the constraint lhs = rhsfield
|
*/
|
*/
|
|
|
static void
|
static void
|
do_lhs_deref_structure_copy (const struct constraint_expr lhs,
|
do_lhs_deref_structure_copy (const struct constraint_expr lhs,
|
const struct constraint_expr rhs,
|
const struct constraint_expr rhs,
|
const unsigned HOST_WIDE_INT size)
|
const unsigned HOST_WIDE_INT size)
|
{
|
{
|
varinfo_t p = get_varinfo (rhs.var);
|
varinfo_t p = get_varinfo (rhs.var);
|
unsigned HOST_WIDE_INT pstart,last;
|
unsigned HOST_WIDE_INT pstart,last;
|
pstart = p->offset;
|
pstart = p->offset;
|
last = p->offset + size;
|
last = p->offset + size;
|
|
|
for (; p && p->offset < last; p = p->next)
|
for (; p && p->offset < last; p = p->next)
|
{
|
{
|
varinfo_t q;
|
varinfo_t q;
|
struct constraint_expr templhs = lhs;
|
struct constraint_expr templhs = lhs;
|
struct constraint_expr temprhs = rhs;
|
struct constraint_expr temprhs = rhs;
|
unsigned HOST_WIDE_INT fieldoffset;
|
unsigned HOST_WIDE_INT fieldoffset;
|
|
|
|
|
if (temprhs.type == SCALAR)
|
if (temprhs.type == SCALAR)
|
temprhs.var = p->id;
|
temprhs.var = p->id;
|
else
|
else
|
temprhs.offset = p->offset;
|
temprhs.offset = p->offset;
|
|
|
q = get_varinfo (templhs.var);
|
q = get_varinfo (templhs.var);
|
fieldoffset = p->offset - pstart;
|
fieldoffset = p->offset - pstart;
|
templhs.offset += fieldoffset;
|
templhs.offset += fieldoffset;
|
process_constraint (new_constraint (templhs, temprhs));
|
process_constraint (new_constraint (templhs, temprhs));
|
}
|
}
|
}
|
}
|
|
|
/* Sometimes, frontends like to give us bad type information. This
|
/* Sometimes, frontends like to give us bad type information. This
|
function will collapse all the fields from VAR to the end of VAR,
|
function will collapse all the fields from VAR to the end of VAR,
|
into VAR, so that we treat those fields as a single variable.
|
into VAR, so that we treat those fields as a single variable.
|
We return the variable they were collapsed into. */
|
We return the variable they were collapsed into. */
|
|
|
static unsigned int
|
static unsigned int
|
collapse_rest_of_var (unsigned int var)
|
collapse_rest_of_var (unsigned int var)
|
{
|
{
|
varinfo_t currvar = get_varinfo (var);
|
varinfo_t currvar = get_varinfo (var);
|
varinfo_t field;
|
varinfo_t field;
|
|
|
for (field = currvar->next; field; field = field->next)
|
for (field = currvar->next; field; field = field->next)
|
{
|
{
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file, "Type safety: Collapsing var %s into %s\n",
|
fprintf (dump_file, "Type safety: Collapsing var %s into %s\n",
|
field->name, currvar->name);
|
field->name, currvar->name);
|
|
|
gcc_assert (!field->collapsed_to);
|
gcc_assert (!field->collapsed_to);
|
field->collapsed_to = currvar;
|
field->collapsed_to = currvar;
|
}
|
}
|
|
|
currvar->next = NULL;
|
currvar->next = NULL;
|
currvar->size = currvar->fullsize - currvar->offset;
|
currvar->size = currvar->fullsize - currvar->offset;
|
|
|
return currvar->id;
|
return currvar->id;
|
}
|
}
|
|
|
/* Handle aggregate copies by expanding into copies of the respective
|
/* Handle aggregate copies by expanding into copies of the respective
|
fields of the structures. */
|
fields of the structures. */
|
|
|
static void
|
static void
|
do_structure_copy (tree lhsop, tree rhsop)
|
do_structure_copy (tree lhsop, tree rhsop)
|
{
|
{
|
struct constraint_expr lhs, rhs, tmp;
|
struct constraint_expr lhs, rhs, tmp;
|
VEC (ce_s, heap) *lhsc = NULL, *rhsc = NULL;
|
VEC (ce_s, heap) *lhsc = NULL, *rhsc = NULL;
|
varinfo_t p;
|
varinfo_t p;
|
unsigned HOST_WIDE_INT lhssize;
|
unsigned HOST_WIDE_INT lhssize;
|
unsigned HOST_WIDE_INT rhssize;
|
unsigned HOST_WIDE_INT rhssize;
|
|
|
get_constraint_for (lhsop, &lhsc);
|
get_constraint_for (lhsop, &lhsc);
|
get_constraint_for (rhsop, &rhsc);
|
get_constraint_for (rhsop, &rhsc);
|
gcc_assert (VEC_length (ce_s, lhsc) == 1);
|
gcc_assert (VEC_length (ce_s, lhsc) == 1);
|
gcc_assert (VEC_length (ce_s, rhsc) == 1);
|
gcc_assert (VEC_length (ce_s, rhsc) == 1);
|
lhs = *(VEC_last (ce_s, lhsc));
|
lhs = *(VEC_last (ce_s, lhsc));
|
rhs = *(VEC_last (ce_s, rhsc));
|
rhs = *(VEC_last (ce_s, rhsc));
|
|
|
VEC_free (ce_s, heap, lhsc);
|
VEC_free (ce_s, heap, lhsc);
|
VEC_free (ce_s, heap, rhsc);
|
VEC_free (ce_s, heap, rhsc);
|
|
|
/* If we have special var = x, swap it around. */
|
/* If we have special var = x, swap it around. */
|
if (lhs.var <= integer_id && !(get_varinfo (rhs.var)->is_special_var))
|
if (lhs.var <= integer_id && !(get_varinfo (rhs.var)->is_special_var))
|
{
|
{
|
tmp = lhs;
|
tmp = lhs;
|
lhs = rhs;
|
lhs = rhs;
|
rhs = tmp;
|
rhs = tmp;
|
}
|
}
|
|
|
/* This is fairly conservative for the RHS == ADDRESSOF case, in that it's
|
/* This is fairly conservative for the RHS == ADDRESSOF case, in that it's
|
possible it's something we could handle. However, most cases falling
|
possible it's something we could handle. However, most cases falling
|
into this are dealing with transparent unions, which are slightly
|
into this are dealing with transparent unions, which are slightly
|
weird. */
|
weird. */
|
if (rhs.type == ADDRESSOF && !(get_varinfo (rhs.var)->is_special_var))
|
if (rhs.type == ADDRESSOF && !(get_varinfo (rhs.var)->is_special_var))
|
{
|
{
|
rhs.type = ADDRESSOF;
|
rhs.type = ADDRESSOF;
|
rhs.var = anything_id;
|
rhs.var = anything_id;
|
}
|
}
|
|
|
/* If the RHS is a special var, or an addressof, set all the LHS fields to
|
/* If the RHS is a special var, or an addressof, set all the LHS fields to
|
that special var. */
|
that special var. */
|
if (rhs.var <= integer_id)
|
if (rhs.var <= integer_id)
|
{
|
{
|
for (p = get_varinfo (lhs.var); p; p = p->next)
|
for (p = get_varinfo (lhs.var); p; p = p->next)
|
{
|
{
|
struct constraint_expr templhs = lhs;
|
struct constraint_expr templhs = lhs;
|
struct constraint_expr temprhs = rhs;
|
struct constraint_expr temprhs = rhs;
|
|
|
if (templhs.type == SCALAR )
|
if (templhs.type == SCALAR )
|
templhs.var = p->id;
|
templhs.var = p->id;
|
else
|
else
|
templhs.offset += p->offset;
|
templhs.offset += p->offset;
|
process_constraint (new_constraint (templhs, temprhs));
|
process_constraint (new_constraint (templhs, temprhs));
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
tree rhstype = TREE_TYPE (rhsop);
|
tree rhstype = TREE_TYPE (rhsop);
|
tree lhstype = TREE_TYPE (lhsop);
|
tree lhstype = TREE_TYPE (lhsop);
|
tree rhstypesize;
|
tree rhstypesize;
|
tree lhstypesize;
|
tree lhstypesize;
|
|
|
lhstypesize = DECL_P (lhsop) ? DECL_SIZE (lhsop) : TYPE_SIZE (lhstype);
|
lhstypesize = DECL_P (lhsop) ? DECL_SIZE (lhsop) : TYPE_SIZE (lhstype);
|
rhstypesize = DECL_P (rhsop) ? DECL_SIZE (rhsop) : TYPE_SIZE (rhstype);
|
rhstypesize = DECL_P (rhsop) ? DECL_SIZE (rhsop) : TYPE_SIZE (rhstype);
|
|
|
/* If we have a variably sized types on the rhs or lhs, and a deref
|
/* If we have a variably sized types on the rhs or lhs, and a deref
|
constraint, add the constraint, lhsconstraint = &ANYTHING.
|
constraint, add the constraint, lhsconstraint = &ANYTHING.
|
This is conservatively correct because either the lhs is an unknown
|
This is conservatively correct because either the lhs is an unknown
|
sized var (if the constraint is SCALAR), or the lhs is a DEREF
|
sized var (if the constraint is SCALAR), or the lhs is a DEREF
|
constraint, and every variable it can point to must be unknown sized
|
constraint, and every variable it can point to must be unknown sized
|
anyway, so we don't need to worry about fields at all. */
|
anyway, so we don't need to worry about fields at all. */
|
if ((rhs.type == DEREF && TREE_CODE (rhstypesize) != INTEGER_CST)
|
if ((rhs.type == DEREF && TREE_CODE (rhstypesize) != INTEGER_CST)
|
|| (lhs.type == DEREF && TREE_CODE (lhstypesize) != INTEGER_CST))
|
|| (lhs.type == DEREF && TREE_CODE (lhstypesize) != INTEGER_CST))
|
{
|
{
|
rhs.var = anything_id;
|
rhs.var = anything_id;
|
rhs.type = ADDRESSOF;
|
rhs.type = ADDRESSOF;
|
rhs.offset = 0;
|
rhs.offset = 0;
|
process_constraint (new_constraint (lhs, rhs));
|
process_constraint (new_constraint (lhs, rhs));
|
return;
|
return;
|
}
|
}
|
|
|
/* The size only really matters insofar as we don't set more or less of
|
/* The size only really matters insofar as we don't set more or less of
|
the variable. If we hit an unknown size var, the size should be the
|
the variable. If we hit an unknown size var, the size should be the
|
whole darn thing. */
|
whole darn thing. */
|
if (get_varinfo (rhs.var)->is_unknown_size_var)
|
if (get_varinfo (rhs.var)->is_unknown_size_var)
|
rhssize = ~0;
|
rhssize = ~0;
|
else
|
else
|
rhssize = TREE_INT_CST_LOW (rhstypesize);
|
rhssize = TREE_INT_CST_LOW (rhstypesize);
|
|
|
if (get_varinfo (lhs.var)->is_unknown_size_var)
|
if (get_varinfo (lhs.var)->is_unknown_size_var)
|
lhssize = ~0;
|
lhssize = ~0;
|
else
|
else
|
lhssize = TREE_INT_CST_LOW (lhstypesize);
|
lhssize = TREE_INT_CST_LOW (lhstypesize);
|
|
|
|
|
if (rhs.type == SCALAR && lhs.type == SCALAR)
|
if (rhs.type == SCALAR && lhs.type == SCALAR)
|
{
|
{
|
if (!do_simple_structure_copy (lhs, rhs, MIN (lhssize, rhssize)))
|
if (!do_simple_structure_copy (lhs, rhs, MIN (lhssize, rhssize)))
|
{
|
{
|
lhs.var = collapse_rest_of_var (lhs.var);
|
lhs.var = collapse_rest_of_var (lhs.var);
|
rhs.var = collapse_rest_of_var (rhs.var);
|
rhs.var = collapse_rest_of_var (rhs.var);
|
lhs.offset = 0;
|
lhs.offset = 0;
|
rhs.offset = 0;
|
rhs.offset = 0;
|
lhs.type = SCALAR;
|
lhs.type = SCALAR;
|
rhs.type = SCALAR;
|
rhs.type = SCALAR;
|
process_constraint (new_constraint (lhs, rhs));
|
process_constraint (new_constraint (lhs, rhs));
|
}
|
}
|
}
|
}
|
else if (lhs.type != DEREF && rhs.type == DEREF)
|
else if (lhs.type != DEREF && rhs.type == DEREF)
|
do_rhs_deref_structure_copy (lhs, rhs, MIN (lhssize, rhssize));
|
do_rhs_deref_structure_copy (lhs, rhs, MIN (lhssize, rhssize));
|
else if (lhs.type == DEREF && rhs.type != DEREF)
|
else if (lhs.type == DEREF && rhs.type != DEREF)
|
do_lhs_deref_structure_copy (lhs, rhs, MIN (lhssize, rhssize));
|
do_lhs_deref_structure_copy (lhs, rhs, MIN (lhssize, rhssize));
|
else
|
else
|
{
|
{
|
tree pointedtotype = lhstype;
|
tree pointedtotype = lhstype;
|
tree tmpvar;
|
tree tmpvar;
|
|
|
gcc_assert (rhs.type == DEREF && lhs.type == DEREF);
|
gcc_assert (rhs.type == DEREF && lhs.type == DEREF);
|
tmpvar = create_tmp_var_raw (pointedtotype, "structcopydereftmp");
|
tmpvar = create_tmp_var_raw (pointedtotype, "structcopydereftmp");
|
do_structure_copy (tmpvar, rhsop);
|
do_structure_copy (tmpvar, rhsop);
|
do_structure_copy (lhsop, tmpvar);
|
do_structure_copy (lhsop, tmpvar);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Update related alias information kept in AI. This is used when
|
/* Update related alias information kept in AI. This is used when
|
building name tags, alias sets and deciding grouping heuristics.
|
building name tags, alias sets and deciding grouping heuristics.
|
STMT is the statement to process. This function also updates
|
STMT is the statement to process. This function also updates
|
ADDRESSABLE_VARS. */
|
ADDRESSABLE_VARS. */
|
|
|
static void
|
static void
|
update_alias_info (tree stmt, struct alias_info *ai)
|
update_alias_info (tree stmt, struct alias_info *ai)
|
{
|
{
|
bitmap addr_taken;
|
bitmap addr_taken;
|
use_operand_p use_p;
|
use_operand_p use_p;
|
ssa_op_iter iter;
|
ssa_op_iter iter;
|
enum escape_type stmt_escape_type = is_escape_site (stmt);
|
enum escape_type stmt_escape_type = is_escape_site (stmt);
|
tree op;
|
tree op;
|
|
|
if (stmt_escape_type == ESCAPE_TO_CALL
|
if (stmt_escape_type == ESCAPE_TO_CALL
|
|| stmt_escape_type == ESCAPE_TO_PURE_CONST)
|
|| stmt_escape_type == ESCAPE_TO_PURE_CONST)
|
{
|
{
|
ai->num_calls_found++;
|
ai->num_calls_found++;
|
if (stmt_escape_type == ESCAPE_TO_PURE_CONST)
|
if (stmt_escape_type == ESCAPE_TO_PURE_CONST)
|
ai->num_pure_const_calls_found++;
|
ai->num_pure_const_calls_found++;
|
}
|
}
|
|
|
/* Mark all the variables whose address are taken by the statement. */
|
/* Mark all the variables whose address are taken by the statement. */
|
addr_taken = addresses_taken (stmt);
|
addr_taken = addresses_taken (stmt);
|
if (addr_taken)
|
if (addr_taken)
|
{
|
{
|
bitmap_ior_into (addressable_vars, addr_taken);
|
bitmap_ior_into (addressable_vars, addr_taken);
|
|
|
/* If STMT is an escape point, all the addresses taken by it are
|
/* If STMT is an escape point, all the addresses taken by it are
|
call-clobbered. */
|
call-clobbered. */
|
if (stmt_escape_type != NO_ESCAPE)
|
if (stmt_escape_type != NO_ESCAPE)
|
{
|
{
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
unsigned i;
|
unsigned i;
|
|
|
EXECUTE_IF_SET_IN_BITMAP (addr_taken, 0, i, bi)
|
EXECUTE_IF_SET_IN_BITMAP (addr_taken, 0, i, bi)
|
{
|
{
|
tree rvar = referenced_var (i);
|
tree rvar = referenced_var (i);
|
if (!unmodifiable_var_p (rvar))
|
if (!unmodifiable_var_p (rvar))
|
mark_call_clobbered (rvar, stmt_escape_type);
|
mark_call_clobbered (rvar, stmt_escape_type);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Process each operand use. If an operand may be aliased, keep
|
/* Process each operand use. If an operand may be aliased, keep
|
track of how many times it's being used. For pointers, determine
|
track of how many times it's being used. For pointers, determine
|
whether they are dereferenced by the statement, or whether their
|
whether they are dereferenced by the statement, or whether their
|
value escapes, etc. */
|
value escapes, etc. */
|
FOR_EACH_PHI_OR_STMT_USE (use_p, stmt, iter, SSA_OP_USE)
|
FOR_EACH_PHI_OR_STMT_USE (use_p, stmt, iter, SSA_OP_USE)
|
{
|
{
|
tree op, var;
|
tree op, var;
|
var_ann_t v_ann;
|
var_ann_t v_ann;
|
struct ptr_info_def *pi;
|
struct ptr_info_def *pi;
|
bool is_store, is_potential_deref;
|
bool is_store, is_potential_deref;
|
unsigned num_uses, num_derefs;
|
unsigned num_uses, num_derefs;
|
|
|
op = USE_FROM_PTR (use_p);
|
op = USE_FROM_PTR (use_p);
|
|
|
/* If STMT is a PHI node, OP may be an ADDR_EXPR. If so, add it
|
/* If STMT is a PHI node, OP may be an ADDR_EXPR. If so, add it
|
to the set of addressable variables. */
|
to the set of addressable variables. */
|
if (TREE_CODE (op) == ADDR_EXPR)
|
if (TREE_CODE (op) == ADDR_EXPR)
|
{
|
{
|
gcc_assert (TREE_CODE (stmt) == PHI_NODE);
|
gcc_assert (TREE_CODE (stmt) == PHI_NODE);
|
|
|
/* PHI nodes don't have annotations for pinning the set
|
/* PHI nodes don't have annotations for pinning the set
|
of addresses taken, so we collect them here.
|
of addresses taken, so we collect them here.
|
|
|
FIXME, should we allow PHI nodes to have annotations
|
FIXME, should we allow PHI nodes to have annotations
|
so that they can be treated like regular statements?
|
so that they can be treated like regular statements?
|
Currently, they are treated as second-class
|
Currently, they are treated as second-class
|
statements. */
|
statements. */
|
add_to_addressable_set (TREE_OPERAND (op, 0), &addressable_vars);
|
add_to_addressable_set (TREE_OPERAND (op, 0), &addressable_vars);
|
continue;
|
continue;
|
}
|
}
|
|
|
/* Ignore constants. */
|
/* Ignore constants. */
|
if (TREE_CODE (op) != SSA_NAME)
|
if (TREE_CODE (op) != SSA_NAME)
|
continue;
|
continue;
|
|
|
var = SSA_NAME_VAR (op);
|
var = SSA_NAME_VAR (op);
|
v_ann = var_ann (var);
|
v_ann = var_ann (var);
|
|
|
/* The base variable of an ssa name must be a GIMPLE register, and thus
|
/* The base variable of an ssa name must be a GIMPLE register, and thus
|
it cannot be aliased. */
|
it cannot be aliased. */
|
gcc_assert (!may_be_aliased (var));
|
gcc_assert (!may_be_aliased (var));
|
|
|
/* We are only interested in pointers. */
|
/* We are only interested in pointers. */
|
if (!POINTER_TYPE_P (TREE_TYPE (op)))
|
if (!POINTER_TYPE_P (TREE_TYPE (op)))
|
continue;
|
continue;
|
|
|
pi = get_ptr_info (op);
|
pi = get_ptr_info (op);
|
|
|
/* Add OP to AI->PROCESSED_PTRS, if it's not there already. */
|
/* Add OP to AI->PROCESSED_PTRS, if it's not there already. */
|
if (!TEST_BIT (ai->ssa_names_visited, SSA_NAME_VERSION (op)))
|
if (!TEST_BIT (ai->ssa_names_visited, SSA_NAME_VERSION (op)))
|
{
|
{
|
SET_BIT (ai->ssa_names_visited, SSA_NAME_VERSION (op));
|
SET_BIT (ai->ssa_names_visited, SSA_NAME_VERSION (op));
|
VEC_safe_push (tree, heap, ai->processed_ptrs, op);
|
VEC_safe_push (tree, heap, ai->processed_ptrs, op);
|
}
|
}
|
|
|
/* If STMT is a PHI node, then it will not have pointer
|
/* If STMT is a PHI node, then it will not have pointer
|
dereferences and it will not be an escape point. */
|
dereferences and it will not be an escape point. */
|
if (TREE_CODE (stmt) == PHI_NODE)
|
if (TREE_CODE (stmt) == PHI_NODE)
|
continue;
|
continue;
|
|
|
/* Determine whether OP is a dereferenced pointer, and if STMT
|
/* Determine whether OP is a dereferenced pointer, and if STMT
|
is an escape point, whether OP escapes. */
|
is an escape point, whether OP escapes. */
|
count_uses_and_derefs (op, stmt, &num_uses, &num_derefs, &is_store);
|
count_uses_and_derefs (op, stmt, &num_uses, &num_derefs, &is_store);
|
|
|
/* Handle a corner case involving address expressions of the
|
/* Handle a corner case involving address expressions of the
|
form '&PTR->FLD'. The problem with these expressions is that
|
form '&PTR->FLD'. The problem with these expressions is that
|
they do not represent a dereference of PTR. However, if some
|
they do not represent a dereference of PTR. However, if some
|
other transformation propagates them into an INDIRECT_REF
|
other transformation propagates them into an INDIRECT_REF
|
expression, we end up with '*(&PTR->FLD)' which is folded
|
expression, we end up with '*(&PTR->FLD)' which is folded
|
into 'PTR->FLD'.
|
into 'PTR->FLD'.
|
|
|
So, if the original code had no other dereferences of PTR,
|
So, if the original code had no other dereferences of PTR,
|
the aliaser will not create memory tags for it, and when
|
the aliaser will not create memory tags for it, and when
|
&PTR->FLD gets propagated to INDIRECT_REF expressions, the
|
&PTR->FLD gets propagated to INDIRECT_REF expressions, the
|
memory operations will receive no V_MAY_DEF/VUSE operands.
|
memory operations will receive no V_MAY_DEF/VUSE operands.
|
|
|
One solution would be to have count_uses_and_derefs consider
|
One solution would be to have count_uses_and_derefs consider
|
&PTR->FLD a dereference of PTR. But that is wrong, since it
|
&PTR->FLD a dereference of PTR. But that is wrong, since it
|
is not really a dereference but an offset calculation.
|
is not really a dereference but an offset calculation.
|
|
|
What we do here is to recognize these special ADDR_EXPR
|
What we do here is to recognize these special ADDR_EXPR
|
nodes. Since these expressions are never GIMPLE values (they
|
nodes. Since these expressions are never GIMPLE values (they
|
are not GIMPLE invariants), they can only appear on the RHS
|
are not GIMPLE invariants), they can only appear on the RHS
|
of an assignment and their base address is always an
|
of an assignment and their base address is always an
|
INDIRECT_REF expression. */
|
INDIRECT_REF expression. */
|
is_potential_deref = false;
|
is_potential_deref = false;
|
if (TREE_CODE (stmt) == MODIFY_EXPR
|
if (TREE_CODE (stmt) == MODIFY_EXPR
|
&& TREE_CODE (TREE_OPERAND (stmt, 1)) == ADDR_EXPR
|
&& TREE_CODE (TREE_OPERAND (stmt, 1)) == ADDR_EXPR
|
&& !is_gimple_val (TREE_OPERAND (stmt, 1)))
|
&& !is_gimple_val (TREE_OPERAND (stmt, 1)))
|
{
|
{
|
/* If the RHS if of the form &PTR->FLD and PTR == OP, then
|
/* If the RHS if of the form &PTR->FLD and PTR == OP, then
|
this represents a potential dereference of PTR. */
|
this represents a potential dereference of PTR. */
|
tree rhs = TREE_OPERAND (stmt, 1);
|
tree rhs = TREE_OPERAND (stmt, 1);
|
tree base = get_base_address (TREE_OPERAND (rhs, 0));
|
tree base = get_base_address (TREE_OPERAND (rhs, 0));
|
if (TREE_CODE (base) == INDIRECT_REF
|
if (TREE_CODE (base) == INDIRECT_REF
|
&& TREE_OPERAND (base, 0) == op)
|
&& TREE_OPERAND (base, 0) == op)
|
is_potential_deref = true;
|
is_potential_deref = true;
|
}
|
}
|
|
|
if (num_derefs > 0 || is_potential_deref)
|
if (num_derefs > 0 || is_potential_deref)
|
{
|
{
|
/* Mark OP as dereferenced. In a subsequent pass,
|
/* Mark OP as dereferenced. In a subsequent pass,
|
dereferenced pointers that point to a set of
|
dereferenced pointers that point to a set of
|
variables will be assigned a name tag to alias
|
variables will be assigned a name tag to alias
|
all the variables OP points to. */
|
all the variables OP points to. */
|
pi->is_dereferenced = 1;
|
pi->is_dereferenced = 1;
|
|
|
/* Keep track of how many time we've dereferenced each
|
/* Keep track of how many time we've dereferenced each
|
pointer. */
|
pointer. */
|
NUM_REFERENCES_INC (v_ann);
|
NUM_REFERENCES_INC (v_ann);
|
|
|
/* If this is a store operation, mark OP as being
|
/* If this is a store operation, mark OP as being
|
dereferenced to store, otherwise mark it as being
|
dereferenced to store, otherwise mark it as being
|
dereferenced to load. */
|
dereferenced to load. */
|
if (is_store)
|
if (is_store)
|
bitmap_set_bit (ai->dereferenced_ptrs_store, DECL_UID (var));
|
bitmap_set_bit (ai->dereferenced_ptrs_store, DECL_UID (var));
|
else
|
else
|
bitmap_set_bit (ai->dereferenced_ptrs_load, DECL_UID (var));
|
bitmap_set_bit (ai->dereferenced_ptrs_load, DECL_UID (var));
|
}
|
}
|
|
|
if (stmt_escape_type != NO_ESCAPE && num_derefs < num_uses)
|
if (stmt_escape_type != NO_ESCAPE && num_derefs < num_uses)
|
{
|
{
|
/* If STMT is an escape point and STMT contains at
|
/* If STMT is an escape point and STMT contains at
|
least one direct use of OP, then the value of OP
|
least one direct use of OP, then the value of OP
|
escapes and so the pointed-to variables need to
|
escapes and so the pointed-to variables need to
|
be marked call-clobbered. */
|
be marked call-clobbered. */
|
pi->value_escapes_p = 1;
|
pi->value_escapes_p = 1;
|
pi->escape_mask |= stmt_escape_type;
|
pi->escape_mask |= stmt_escape_type;
|
|
|
/* If the statement makes a function call, assume
|
/* If the statement makes a function call, assume
|
that pointer OP will be dereferenced in a store
|
that pointer OP will be dereferenced in a store
|
operation inside the called function. */
|
operation inside the called function. */
|
if (get_call_expr_in (stmt)
|
if (get_call_expr_in (stmt)
|
|| stmt_escape_type == ESCAPE_STORED_IN_GLOBAL)
|
|| stmt_escape_type == ESCAPE_STORED_IN_GLOBAL)
|
{
|
{
|
bitmap_set_bit (ai->dereferenced_ptrs_store, DECL_UID (var));
|
bitmap_set_bit (ai->dereferenced_ptrs_store, DECL_UID (var));
|
pi->is_dereferenced = 1;
|
pi->is_dereferenced = 1;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (TREE_CODE (stmt) == PHI_NODE)
|
if (TREE_CODE (stmt) == PHI_NODE)
|
return;
|
return;
|
|
|
/* Update reference counter for definitions to any
|
/* Update reference counter for definitions to any
|
potentially aliased variable. This is used in the alias
|
potentially aliased variable. This is used in the alias
|
grouping heuristics. */
|
grouping heuristics. */
|
FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_DEF)
|
FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_DEF)
|
{
|
{
|
tree var = SSA_NAME_VAR (op);
|
tree var = SSA_NAME_VAR (op);
|
var_ann_t ann = var_ann (var);
|
var_ann_t ann = var_ann (var);
|
bitmap_set_bit (ai->written_vars, DECL_UID (var));
|
bitmap_set_bit (ai->written_vars, DECL_UID (var));
|
if (may_be_aliased (var))
|
if (may_be_aliased (var))
|
NUM_REFERENCES_INC (ann);
|
NUM_REFERENCES_INC (ann);
|
|
|
}
|
}
|
|
|
/* Mark variables in V_MAY_DEF operands as being written to. */
|
/* Mark variables in V_MAY_DEF operands as being written to. */
|
FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_VIRTUAL_DEFS)
|
FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_VIRTUAL_DEFS)
|
{
|
{
|
tree var = DECL_P (op) ? op : SSA_NAME_VAR (op);
|
tree var = DECL_P (op) ? op : SSA_NAME_VAR (op);
|
bitmap_set_bit (ai->written_vars, DECL_UID (var));
|
bitmap_set_bit (ai->written_vars, DECL_UID (var));
|
}
|
}
|
}
|
}
|
|
|
/* Handle pointer arithmetic EXPR when creating aliasing constraints.
|
/* Handle pointer arithmetic EXPR when creating aliasing constraints.
|
Expressions of the type PTR + CST can be handled in two ways:
|
Expressions of the type PTR + CST can be handled in two ways:
|
|
|
1- If the constraint for PTR is ADDRESSOF for a non-structure
|
1- If the constraint for PTR is ADDRESSOF for a non-structure
|
variable, then we can use it directly because adding or
|
variable, then we can use it directly because adding or
|
subtracting a constant may not alter the original ADDRESSOF
|
subtracting a constant may not alter the original ADDRESSOF
|
constraint (i.e., pointer arithmetic may not legally go outside
|
constraint (i.e., pointer arithmetic may not legally go outside
|
an object's boundaries).
|
an object's boundaries).
|
|
|
2- If the constraint for PTR is ADDRESSOF for a structure variable,
|
2- If the constraint for PTR is ADDRESSOF for a structure variable,
|
then if CST is a compile-time constant that can be used as an
|
then if CST is a compile-time constant that can be used as an
|
offset, we can determine which sub-variable will be pointed-to
|
offset, we can determine which sub-variable will be pointed-to
|
by the expression.
|
by the expression.
|
|
|
Return true if the expression is handled. For any other kind of
|
Return true if the expression is handled. For any other kind of
|
expression, return false so that each operand can be added as a
|
expression, return false so that each operand can be added as a
|
separate constraint by the caller. */
|
separate constraint by the caller. */
|
|
|
static bool
|
static bool
|
handle_ptr_arith (VEC (ce_s, heap) *lhsc, tree expr)
|
handle_ptr_arith (VEC (ce_s, heap) *lhsc, tree expr)
|
{
|
{
|
tree op0, op1;
|
tree op0, op1;
|
struct constraint_expr *c, *c2;
|
struct constraint_expr *c, *c2;
|
unsigned int i = 0;
|
unsigned int i = 0;
|
unsigned int j = 0;
|
unsigned int j = 0;
|
VEC (ce_s, heap) *temp = NULL;
|
VEC (ce_s, heap) *temp = NULL;
|
unsigned HOST_WIDE_INT rhsoffset = 0;
|
unsigned HOST_WIDE_INT rhsoffset = 0;
|
|
|
if (TREE_CODE (expr) != PLUS_EXPR
|
if (TREE_CODE (expr) != PLUS_EXPR
|
&& TREE_CODE (expr) != MINUS_EXPR)
|
&& TREE_CODE (expr) != MINUS_EXPR)
|
return false;
|
return false;
|
|
|
op0 = TREE_OPERAND (expr, 0);
|
op0 = TREE_OPERAND (expr, 0);
|
op1 = TREE_OPERAND (expr, 1);
|
op1 = TREE_OPERAND (expr, 1);
|
|
|
get_constraint_for (op0, &temp);
|
get_constraint_for (op0, &temp);
|
if (POINTER_TYPE_P (TREE_TYPE (op0))
|
if (POINTER_TYPE_P (TREE_TYPE (op0))
|
&& host_integerp (op1, 1)
|
&& host_integerp (op1, 1)
|
&& TREE_CODE (expr) == PLUS_EXPR)
|
&& TREE_CODE (expr) == PLUS_EXPR)
|
{
|
{
|
if ((TREE_INT_CST_LOW (op1) * BITS_PER_UNIT) / BITS_PER_UNIT
|
if ((TREE_INT_CST_LOW (op1) * BITS_PER_UNIT) / BITS_PER_UNIT
|
!= TREE_INT_CST_LOW (op1))
|
!= TREE_INT_CST_LOW (op1))
|
return false;
|
return false;
|
rhsoffset = TREE_INT_CST_LOW (op1) * BITS_PER_UNIT;
|
rhsoffset = TREE_INT_CST_LOW (op1) * BITS_PER_UNIT;
|
}
|
}
|
else
|
else
|
return false;
|
return false;
|
|
|
|
|
for (i = 0; VEC_iterate (ce_s, lhsc, i, c); i++)
|
for (i = 0; VEC_iterate (ce_s, lhsc, i, c); i++)
|
for (j = 0; VEC_iterate (ce_s, temp, j, c2); j++)
|
for (j = 0; VEC_iterate (ce_s, temp, j, c2); j++)
|
{
|
{
|
if (c2->type == ADDRESSOF && rhsoffset != 0)
|
if (c2->type == ADDRESSOF && rhsoffset != 0)
|
{
|
{
|
varinfo_t temp = get_varinfo (c2->var);
|
varinfo_t temp = get_varinfo (c2->var);
|
|
|
/* An access one after the end of an array is valid,
|
/* An access one after the end of an array is valid,
|
so simply punt on accesses we cannot resolve. */
|
so simply punt on accesses we cannot resolve. */
|
temp = first_vi_for_offset (temp, rhsoffset);
|
temp = first_vi_for_offset (temp, rhsoffset);
|
if (temp == NULL)
|
if (temp == NULL)
|
continue;
|
continue;
|
c2->var = temp->id;
|
c2->var = temp->id;
|
c2->offset = 0;
|
c2->offset = 0;
|
}
|
}
|
else
|
else
|
c2->offset = rhsoffset;
|
c2->offset = rhsoffset;
|
process_constraint (new_constraint (*c, *c2));
|
process_constraint (new_constraint (*c, *c2));
|
}
|
}
|
|
|
VEC_free (ce_s, heap, temp);
|
VEC_free (ce_s, heap, temp);
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
|
|
/* Walk statement T setting up aliasing constraints according to the
|
/* Walk statement T setting up aliasing constraints according to the
|
references found in T. This function is the main part of the
|
references found in T. This function is the main part of the
|
constraint builder. AI points to auxiliary alias information used
|
constraint builder. AI points to auxiliary alias information used
|
when building alias sets and computing alias grouping heuristics. */
|
when building alias sets and computing alias grouping heuristics. */
|
|
|
static void
|
static void
|
find_func_aliases (tree origt)
|
find_func_aliases (tree origt)
|
{
|
{
|
tree t = origt;
|
tree t = origt;
|
VEC(ce_s, heap) *lhsc = NULL;
|
VEC(ce_s, heap) *lhsc = NULL;
|
VEC(ce_s, heap) *rhsc = NULL;
|
VEC(ce_s, heap) *rhsc = NULL;
|
struct constraint_expr *c;
|
struct constraint_expr *c;
|
|
|
if (TREE_CODE (t) == RETURN_EXPR && TREE_OPERAND (t, 0))
|
if (TREE_CODE (t) == RETURN_EXPR && TREE_OPERAND (t, 0))
|
t = TREE_OPERAND (t, 0);
|
t = TREE_OPERAND (t, 0);
|
|
|
/* Now build constraints expressions. */
|
/* Now build constraints expressions. */
|
if (TREE_CODE (t) == PHI_NODE)
|
if (TREE_CODE (t) == PHI_NODE)
|
{
|
{
|
gcc_assert (!AGGREGATE_TYPE_P (TREE_TYPE (PHI_RESULT (t))));
|
gcc_assert (!AGGREGATE_TYPE_P (TREE_TYPE (PHI_RESULT (t))));
|
|
|
/* Only care about pointers and structures containing
|
/* Only care about pointers and structures containing
|
pointers. */
|
pointers. */
|
if (could_have_pointers (PHI_RESULT (t)))
|
if (could_have_pointers (PHI_RESULT (t)))
|
{
|
{
|
int i;
|
int i;
|
unsigned int j;
|
unsigned int j;
|
|
|
/* For a phi node, assign all the arguments to
|
/* For a phi node, assign all the arguments to
|
the result. */
|
the result. */
|
get_constraint_for (PHI_RESULT (t), &lhsc);
|
get_constraint_for (PHI_RESULT (t), &lhsc);
|
for (i = 0; i < PHI_NUM_ARGS (t); i++)
|
for (i = 0; i < PHI_NUM_ARGS (t); i++)
|
{
|
{
|
tree rhstype;
|
tree rhstype;
|
tree strippedrhs = PHI_ARG_DEF (t, i);
|
tree strippedrhs = PHI_ARG_DEF (t, i);
|
|
|
STRIP_NOPS (strippedrhs);
|
STRIP_NOPS (strippedrhs);
|
rhstype = TREE_TYPE (strippedrhs);
|
rhstype = TREE_TYPE (strippedrhs);
|
get_constraint_for (PHI_ARG_DEF (t, i), &rhsc);
|
get_constraint_for (PHI_ARG_DEF (t, i), &rhsc);
|
|
|
for (j = 0; VEC_iterate (ce_s, lhsc, j, c); j++)
|
for (j = 0; VEC_iterate (ce_s, lhsc, j, c); j++)
|
{
|
{
|
struct constraint_expr *c2;
|
struct constraint_expr *c2;
|
while (VEC_length (ce_s, rhsc) > 0)
|
while (VEC_length (ce_s, rhsc) > 0)
|
{
|
{
|
c2 = VEC_last (ce_s, rhsc);
|
c2 = VEC_last (ce_s, rhsc);
|
process_constraint (new_constraint (*c, *c2));
|
process_constraint (new_constraint (*c, *c2));
|
VEC_pop (ce_s, rhsc);
|
VEC_pop (ce_s, rhsc);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
/* In IPA mode, we need to generate constraints to pass call
|
/* In IPA mode, we need to generate constraints to pass call
|
arguments through their calls. There are two case, either a
|
arguments through their calls. There are two case, either a
|
modify_expr when we are returning a value, or just a plain
|
modify_expr when we are returning a value, or just a plain
|
call_expr when we are not. */
|
call_expr when we are not. */
|
else if (in_ipa_mode
|
else if (in_ipa_mode
|
&& ((TREE_CODE (t) == MODIFY_EXPR
|
&& ((TREE_CODE (t) == MODIFY_EXPR
|
&& TREE_CODE (TREE_OPERAND (t, 1)) == CALL_EXPR
|
&& TREE_CODE (TREE_OPERAND (t, 1)) == CALL_EXPR
|
&& !(call_expr_flags (TREE_OPERAND (t, 1))
|
&& !(call_expr_flags (TREE_OPERAND (t, 1))
|
& (ECF_MALLOC | ECF_MAY_BE_ALLOCA)))
|
& (ECF_MALLOC | ECF_MAY_BE_ALLOCA)))
|
|| (TREE_CODE (t) == CALL_EXPR
|
|| (TREE_CODE (t) == CALL_EXPR
|
&& !(call_expr_flags (t)
|
&& !(call_expr_flags (t)
|
& (ECF_MALLOC | ECF_MAY_BE_ALLOCA)))))
|
& (ECF_MALLOC | ECF_MAY_BE_ALLOCA)))))
|
{
|
{
|
tree lhsop;
|
tree lhsop;
|
tree rhsop;
|
tree rhsop;
|
tree arglist;
|
tree arglist;
|
varinfo_t fi;
|
varinfo_t fi;
|
int i = 1;
|
int i = 1;
|
tree decl;
|
tree decl;
|
if (TREE_CODE (t) == MODIFY_EXPR)
|
if (TREE_CODE (t) == MODIFY_EXPR)
|
{
|
{
|
lhsop = TREE_OPERAND (t, 0);
|
lhsop = TREE_OPERAND (t, 0);
|
rhsop = TREE_OPERAND (t, 1);
|
rhsop = TREE_OPERAND (t, 1);
|
}
|
}
|
else
|
else
|
{
|
{
|
lhsop = NULL;
|
lhsop = NULL;
|
rhsop = t;
|
rhsop = t;
|
}
|
}
|
decl = get_callee_fndecl (rhsop);
|
decl = get_callee_fndecl (rhsop);
|
|
|
/* If we can directly resolve the function being called, do so.
|
/* If we can directly resolve the function being called, do so.
|
Otherwise, it must be some sort of indirect expression that
|
Otherwise, it must be some sort of indirect expression that
|
we should still be able to handle. */
|
we should still be able to handle. */
|
if (decl)
|
if (decl)
|
{
|
{
|
fi = get_vi_for_tree (decl);
|
fi = get_vi_for_tree (decl);
|
}
|
}
|
else
|
else
|
{
|
{
|
decl = TREE_OPERAND (rhsop, 0);
|
decl = TREE_OPERAND (rhsop, 0);
|
fi = get_vi_for_tree (decl);
|
fi = get_vi_for_tree (decl);
|
}
|
}
|
|
|
/* Assign all the passed arguments to the appropriate incoming
|
/* Assign all the passed arguments to the appropriate incoming
|
parameters of the function. */
|
parameters of the function. */
|
arglist = TREE_OPERAND (rhsop, 1);
|
arglist = TREE_OPERAND (rhsop, 1);
|
|
|
for (;arglist; arglist = TREE_CHAIN (arglist))
|
for (;arglist; arglist = TREE_CHAIN (arglist))
|
{
|
{
|
tree arg = TREE_VALUE (arglist);
|
tree arg = TREE_VALUE (arglist);
|
struct constraint_expr lhs ;
|
struct constraint_expr lhs ;
|
struct constraint_expr *rhsp;
|
struct constraint_expr *rhsp;
|
|
|
get_constraint_for (arg, &rhsc);
|
get_constraint_for (arg, &rhsc);
|
if (TREE_CODE (decl) != FUNCTION_DECL)
|
if (TREE_CODE (decl) != FUNCTION_DECL)
|
{
|
{
|
lhs.type = DEREF;
|
lhs.type = DEREF;
|
lhs.var = fi->id;
|
lhs.var = fi->id;
|
lhs.offset = i;
|
lhs.offset = i;
|
}
|
}
|
else
|
else
|
{
|
{
|
lhs.type = SCALAR;
|
lhs.type = SCALAR;
|
lhs.var = first_vi_for_offset (fi, i)->id;
|
lhs.var = first_vi_for_offset (fi, i)->id;
|
lhs.offset = 0;
|
lhs.offset = 0;
|
}
|
}
|
while (VEC_length (ce_s, rhsc) != 0)
|
while (VEC_length (ce_s, rhsc) != 0)
|
{
|
{
|
rhsp = VEC_last (ce_s, rhsc);
|
rhsp = VEC_last (ce_s, rhsc);
|
process_constraint (new_constraint (lhs, *rhsp));
|
process_constraint (new_constraint (lhs, *rhsp));
|
VEC_pop (ce_s, rhsc);
|
VEC_pop (ce_s, rhsc);
|
}
|
}
|
i++;
|
i++;
|
}
|
}
|
|
|
/* If we are returning a value, assign it to the result. */
|
/* If we are returning a value, assign it to the result. */
|
if (lhsop)
|
if (lhsop)
|
{
|
{
|
struct constraint_expr rhs;
|
struct constraint_expr rhs;
|
struct constraint_expr *lhsp;
|
struct constraint_expr *lhsp;
|
unsigned int j = 0;
|
unsigned int j = 0;
|
|
|
get_constraint_for (lhsop, &lhsc);
|
get_constraint_for (lhsop, &lhsc);
|
if (TREE_CODE (decl) != FUNCTION_DECL)
|
if (TREE_CODE (decl) != FUNCTION_DECL)
|
{
|
{
|
rhs.type = DEREF;
|
rhs.type = DEREF;
|
rhs.var = fi->id;
|
rhs.var = fi->id;
|
rhs.offset = i;
|
rhs.offset = i;
|
}
|
}
|
else
|
else
|
{
|
{
|
rhs.type = SCALAR;
|
rhs.type = SCALAR;
|
rhs.var = first_vi_for_offset (fi, i)->id;
|
rhs.var = first_vi_for_offset (fi, i)->id;
|
rhs.offset = 0;
|
rhs.offset = 0;
|
}
|
}
|
for (j = 0; VEC_iterate (ce_s, lhsc, j, lhsp); j++)
|
for (j = 0; VEC_iterate (ce_s, lhsc, j, lhsp); j++)
|
process_constraint (new_constraint (*lhsp, rhs));
|
process_constraint (new_constraint (*lhsp, rhs));
|
}
|
}
|
}
|
}
|
/* Otherwise, just a regular assignment statement. */
|
/* Otherwise, just a regular assignment statement. */
|
else if (TREE_CODE (t) == MODIFY_EXPR)
|
else if (TREE_CODE (t) == MODIFY_EXPR)
|
{
|
{
|
tree lhsop = TREE_OPERAND (t, 0);
|
tree lhsop = TREE_OPERAND (t, 0);
|
tree rhsop = TREE_OPERAND (t, 1);
|
tree rhsop = TREE_OPERAND (t, 1);
|
int i;
|
int i;
|
|
|
if ((AGGREGATE_TYPE_P (TREE_TYPE (lhsop))
|
if ((AGGREGATE_TYPE_P (TREE_TYPE (lhsop))
|
|| TREE_CODE (TREE_TYPE (lhsop)) == COMPLEX_TYPE)
|
|| TREE_CODE (TREE_TYPE (lhsop)) == COMPLEX_TYPE)
|
&& (AGGREGATE_TYPE_P (TREE_TYPE (rhsop))
|
&& (AGGREGATE_TYPE_P (TREE_TYPE (rhsop))
|
|| TREE_CODE (TREE_TYPE (lhsop)) == COMPLEX_TYPE))
|
|| TREE_CODE (TREE_TYPE (lhsop)) == COMPLEX_TYPE))
|
{
|
{
|
do_structure_copy (lhsop, rhsop);
|
do_structure_copy (lhsop, rhsop);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Only care about operations with pointers, structures
|
/* Only care about operations with pointers, structures
|
containing pointers, dereferences, and call expressions. */
|
containing pointers, dereferences, and call expressions. */
|
if (could_have_pointers (lhsop)
|
if (could_have_pointers (lhsop)
|
|| TREE_CODE (rhsop) == CALL_EXPR)
|
|| TREE_CODE (rhsop) == CALL_EXPR)
|
{
|
{
|
get_constraint_for (lhsop, &lhsc);
|
get_constraint_for (lhsop, &lhsc);
|
switch (TREE_CODE_CLASS (TREE_CODE (rhsop)))
|
switch (TREE_CODE_CLASS (TREE_CODE (rhsop)))
|
{
|
{
|
/* RHS that consist of unary operations,
|
/* RHS that consist of unary operations,
|
exceptional types, or bare decls/constants, get
|
exceptional types, or bare decls/constants, get
|
handled directly by get_constraint_for. */
|
handled directly by get_constraint_for. */
|
case tcc_reference:
|
case tcc_reference:
|
case tcc_declaration:
|
case tcc_declaration:
|
case tcc_constant:
|
case tcc_constant:
|
case tcc_exceptional:
|
case tcc_exceptional:
|
case tcc_expression:
|
case tcc_expression:
|
case tcc_unary:
|
case tcc_unary:
|
{
|
{
|
unsigned int j;
|
unsigned int j;
|
|
|
get_constraint_for (rhsop, &rhsc);
|
get_constraint_for (rhsop, &rhsc);
|
for (j = 0; VEC_iterate (ce_s, lhsc, j, c); j++)
|
for (j = 0; VEC_iterate (ce_s, lhsc, j, c); j++)
|
{
|
{
|
struct constraint_expr *c2;
|
struct constraint_expr *c2;
|
unsigned int k;
|
unsigned int k;
|
|
|
for (k = 0; VEC_iterate (ce_s, rhsc, k, c2); k++)
|
for (k = 0; VEC_iterate (ce_s, rhsc, k, c2); k++)
|
process_constraint (new_constraint (*c, *c2));
|
process_constraint (new_constraint (*c, *c2));
|
}
|
}
|
|
|
}
|
}
|
break;
|
break;
|
|
|
case tcc_binary:
|
case tcc_binary:
|
{
|
{
|
/* For pointer arithmetic of the form
|
/* For pointer arithmetic of the form
|
PTR + CST, we can simply use PTR's
|
PTR + CST, we can simply use PTR's
|
constraint because pointer arithmetic is
|
constraint because pointer arithmetic is
|
not allowed to go out of bounds. */
|
not allowed to go out of bounds. */
|
if (handle_ptr_arith (lhsc, rhsop))
|
if (handle_ptr_arith (lhsc, rhsop))
|
break;
|
break;
|
}
|
}
|
/* FALLTHRU */
|
/* FALLTHRU */
|
|
|
/* Otherwise, walk each operand. Notice that we
|
/* Otherwise, walk each operand. Notice that we
|
can't use the operand interface because we need
|
can't use the operand interface because we need
|
to process expressions other than simple operands
|
to process expressions other than simple operands
|
(e.g. INDIRECT_REF, ADDR_EXPR, CALL_EXPR). */
|
(e.g. INDIRECT_REF, ADDR_EXPR, CALL_EXPR). */
|
default:
|
default:
|
for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (rhsop)); i++)
|
for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (rhsop)); i++)
|
{
|
{
|
tree op = TREE_OPERAND (rhsop, i);
|
tree op = TREE_OPERAND (rhsop, i);
|
unsigned int j;
|
unsigned int j;
|
|
|
gcc_assert (VEC_length (ce_s, rhsc) == 0);
|
gcc_assert (VEC_length (ce_s, rhsc) == 0);
|
get_constraint_for (op, &rhsc);
|
get_constraint_for (op, &rhsc);
|
for (j = 0; VEC_iterate (ce_s, lhsc, j, c); j++)
|
for (j = 0; VEC_iterate (ce_s, lhsc, j, c); j++)
|
{
|
{
|
struct constraint_expr *c2;
|
struct constraint_expr *c2;
|
while (VEC_length (ce_s, rhsc) > 0)
|
while (VEC_length (ce_s, rhsc) > 0)
|
{
|
{
|
c2 = VEC_last (ce_s, rhsc);
|
c2 = VEC_last (ce_s, rhsc);
|
process_constraint (new_constraint (*c, *c2));
|
process_constraint (new_constraint (*c, *c2));
|
VEC_pop (ce_s, rhsc);
|
VEC_pop (ce_s, rhsc);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* After promoting variables and computing aliasing we will
|
/* After promoting variables and computing aliasing we will
|
need to re-scan most statements. FIXME: Try to minimize the
|
need to re-scan most statements. FIXME: Try to minimize the
|
number of statements re-scanned. It's not really necessary to
|
number of statements re-scanned. It's not really necessary to
|
re-scan *all* statements. */
|
re-scan *all* statements. */
|
mark_stmt_modified (origt);
|
mark_stmt_modified (origt);
|
VEC_free (ce_s, heap, rhsc);
|
VEC_free (ce_s, heap, rhsc);
|
VEC_free (ce_s, heap, lhsc);
|
VEC_free (ce_s, heap, lhsc);
|
}
|
}
|
|
|
|
|
/* Find the first varinfo in the same variable as START that overlaps with
|
/* Find the first varinfo in the same variable as START that overlaps with
|
OFFSET.
|
OFFSET.
|
Effectively, walk the chain of fields for the variable START to find the
|
Effectively, walk the chain of fields for the variable START to find the
|
first field that overlaps with OFFSET.
|
first field that overlaps with OFFSET.
|
Return NULL if we can't find one. */
|
Return NULL if we can't find one. */
|
|
|
static varinfo_t
|
static varinfo_t
|
first_vi_for_offset (varinfo_t start, unsigned HOST_WIDE_INT offset)
|
first_vi_for_offset (varinfo_t start, unsigned HOST_WIDE_INT offset)
|
{
|
{
|
varinfo_t curr = start;
|
varinfo_t curr = start;
|
while (curr)
|
while (curr)
|
{
|
{
|
/* We may not find a variable in the field list with the actual
|
/* We may not find a variable in the field list with the actual
|
offset when when we have glommed a structure to a variable.
|
offset when when we have glommed a structure to a variable.
|
In that case, however, offset should still be within the size
|
In that case, however, offset should still be within the size
|
of the variable. */
|
of the variable. */
|
if (offset >= curr->offset && offset < (curr->offset + curr->size))
|
if (offset >= curr->offset && offset < (curr->offset + curr->size))
|
return curr;
|
return curr;
|
curr = curr->next;
|
curr = curr->next;
|
}
|
}
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
|
|
/* Insert the varinfo FIELD into the field list for BASE, at the front
|
/* Insert the varinfo FIELD into the field list for BASE, at the front
|
of the list. */
|
of the list. */
|
|
|
static void
|
static void
|
insert_into_field_list (varinfo_t base, varinfo_t field)
|
insert_into_field_list (varinfo_t base, varinfo_t field)
|
{
|
{
|
varinfo_t prev = base;
|
varinfo_t prev = base;
|
varinfo_t curr = base->next;
|
varinfo_t curr = base->next;
|
|
|
field->next = curr;
|
field->next = curr;
|
prev->next = field;
|
prev->next = field;
|
}
|
}
|
|
|
/* Insert the varinfo FIELD into the field list for BASE, ordered by
|
/* Insert the varinfo FIELD into the field list for BASE, ordered by
|
offset. */
|
offset. */
|
|
|
static void
|
static void
|
insert_into_field_list_sorted (varinfo_t base, varinfo_t field)
|
insert_into_field_list_sorted (varinfo_t base, varinfo_t field)
|
{
|
{
|
varinfo_t prev = base;
|
varinfo_t prev = base;
|
varinfo_t curr = base->next;
|
varinfo_t curr = base->next;
|
|
|
if (curr == NULL)
|
if (curr == NULL)
|
{
|
{
|
prev->next = field;
|
prev->next = field;
|
field->next = NULL;
|
field->next = NULL;
|
}
|
}
|
else
|
else
|
{
|
{
|
while (curr)
|
while (curr)
|
{
|
{
|
if (field->offset <= curr->offset)
|
if (field->offset <= curr->offset)
|
break;
|
break;
|
prev = curr;
|
prev = curr;
|
curr = curr->next;
|
curr = curr->next;
|
}
|
}
|
field->next = prev->next;
|
field->next = prev->next;
|
prev->next = field;
|
prev->next = field;
|
}
|
}
|
}
|
}
|
|
|
/* qsort comparison function for two fieldoff's PA and PB */
|
/* qsort comparison function for two fieldoff's PA and PB */
|
|
|
static int
|
static int
|
fieldoff_compare (const void *pa, const void *pb)
|
fieldoff_compare (const void *pa, const void *pb)
|
{
|
{
|
const fieldoff_s *foa = (const fieldoff_s *)pa;
|
const fieldoff_s *foa = (const fieldoff_s *)pa;
|
const fieldoff_s *fob = (const fieldoff_s *)pb;
|
const fieldoff_s *fob = (const fieldoff_s *)pb;
|
HOST_WIDE_INT foasize, fobsize;
|
HOST_WIDE_INT foasize, fobsize;
|
|
|
if (foa->offset != fob->offset)
|
if (foa->offset != fob->offset)
|
return foa->offset - fob->offset;
|
return foa->offset - fob->offset;
|
|
|
foasize = TREE_INT_CST_LOW (foa->size);
|
foasize = TREE_INT_CST_LOW (foa->size);
|
fobsize = TREE_INT_CST_LOW (fob->size);
|
fobsize = TREE_INT_CST_LOW (fob->size);
|
return foasize - fobsize;
|
return foasize - fobsize;
|
}
|
}
|
|
|
/* Sort a fieldstack according to the field offset and sizes. */
|
/* Sort a fieldstack according to the field offset and sizes. */
|
void
|
void
|
sort_fieldstack (VEC(fieldoff_s,heap) *fieldstack)
|
sort_fieldstack (VEC(fieldoff_s,heap) *fieldstack)
|
{
|
{
|
qsort (VEC_address (fieldoff_s, fieldstack),
|
qsort (VEC_address (fieldoff_s, fieldstack),
|
VEC_length (fieldoff_s, fieldstack),
|
VEC_length (fieldoff_s, fieldstack),
|
sizeof (fieldoff_s),
|
sizeof (fieldoff_s),
|
fieldoff_compare);
|
fieldoff_compare);
|
}
|
}
|
|
|
/* Given a TYPE, and a vector of field offsets FIELDSTACK, push all the fields
|
/* Given a TYPE, and a vector of field offsets FIELDSTACK, push all the fields
|
of TYPE onto fieldstack, recording their offsets along the way.
|
of TYPE onto fieldstack, recording their offsets along the way.
|
OFFSET is used to keep track of the offset in this entire structure, rather
|
OFFSET is used to keep track of the offset in this entire structure, rather
|
than just the immediately containing structure. Returns the number
|
than just the immediately containing structure. Returns the number
|
of fields pushed.
|
of fields pushed.
|
HAS_UNION is set to true if we find a union type as a field of
|
HAS_UNION is set to true if we find a union type as a field of
|
TYPE. */
|
TYPE. */
|
|
|
int
|
int
|
push_fields_onto_fieldstack (tree type, VEC(fieldoff_s,heap) **fieldstack,
|
push_fields_onto_fieldstack (tree type, VEC(fieldoff_s,heap) **fieldstack,
|
HOST_WIDE_INT offset, bool *has_union)
|
HOST_WIDE_INT offset, bool *has_union)
|
{
|
{
|
tree field;
|
tree field;
|
int count = 0;
|
int count = 0;
|
unsigned HOST_WIDE_INT minoffset = -1;
|
unsigned HOST_WIDE_INT minoffset = -1;
|
|
|
if (TREE_CODE (type) == COMPLEX_TYPE)
|
if (TREE_CODE (type) == COMPLEX_TYPE)
|
{
|
{
|
fieldoff_s *real_part, *img_part;
|
fieldoff_s *real_part, *img_part;
|
real_part = VEC_safe_push (fieldoff_s, heap, *fieldstack, NULL);
|
real_part = VEC_safe_push (fieldoff_s, heap, *fieldstack, NULL);
|
real_part->type = TREE_TYPE (type);
|
real_part->type = TREE_TYPE (type);
|
real_part->size = TYPE_SIZE (TREE_TYPE (type));
|
real_part->size = TYPE_SIZE (TREE_TYPE (type));
|
real_part->offset = offset;
|
real_part->offset = offset;
|
real_part->decl = NULL_TREE;
|
real_part->decl = NULL_TREE;
|
|
|
img_part = VEC_safe_push (fieldoff_s, heap, *fieldstack, NULL);
|
img_part = VEC_safe_push (fieldoff_s, heap, *fieldstack, NULL);
|
img_part->type = TREE_TYPE (type);
|
img_part->type = TREE_TYPE (type);
|
img_part->size = TYPE_SIZE (TREE_TYPE (type));
|
img_part->size = TYPE_SIZE (TREE_TYPE (type));
|
img_part->offset = offset + TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (type)));
|
img_part->offset = offset + TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (type)));
|
img_part->decl = NULL_TREE;
|
img_part->decl = NULL_TREE;
|
|
|
return 2;
|
return 2;
|
}
|
}
|
|
|
if (TREE_CODE (type) == ARRAY_TYPE)
|
if (TREE_CODE (type) == ARRAY_TYPE)
|
{
|
{
|
tree sz = TYPE_SIZE (type);
|
tree sz = TYPE_SIZE (type);
|
tree elsz = TYPE_SIZE (TREE_TYPE (type));
|
tree elsz = TYPE_SIZE (TREE_TYPE (type));
|
HOST_WIDE_INT nr;
|
HOST_WIDE_INT nr;
|
int i;
|
int i;
|
|
|
if (! sz
|
if (! sz
|
|| ! host_integerp (sz, 1)
|
|| ! host_integerp (sz, 1)
|
|| TREE_INT_CST_LOW (sz) == 0
|
|| TREE_INT_CST_LOW (sz) == 0
|
|| ! elsz
|
|| ! elsz
|
|| ! host_integerp (elsz, 1)
|
|| ! host_integerp (elsz, 1)
|
|| TREE_INT_CST_LOW (elsz) == 0)
|
|| TREE_INT_CST_LOW (elsz) == 0)
|
return 0;
|
return 0;
|
|
|
nr = TREE_INT_CST_LOW (sz) / TREE_INT_CST_LOW (elsz);
|
nr = TREE_INT_CST_LOW (sz) / TREE_INT_CST_LOW (elsz);
|
if (nr > SALIAS_MAX_ARRAY_ELEMENTS)
|
if (nr > SALIAS_MAX_ARRAY_ELEMENTS)
|
return 0;
|
return 0;
|
|
|
for (i = 0; i < nr; ++i)
|
for (i = 0; i < nr; ++i)
|
{
|
{
|
bool push = false;
|
bool push = false;
|
int pushed = 0;
|
int pushed = 0;
|
|
|
if (has_union
|
if (has_union
|
&& (TREE_CODE (TREE_TYPE (type)) == QUAL_UNION_TYPE
|
&& (TREE_CODE (TREE_TYPE (type)) == QUAL_UNION_TYPE
|
|| TREE_CODE (TREE_TYPE (type)) == UNION_TYPE))
|
|| TREE_CODE (TREE_TYPE (type)) == UNION_TYPE))
|
*has_union = true;
|
*has_union = true;
|
|
|
if (!AGGREGATE_TYPE_P (TREE_TYPE (type))) /* var_can_have_subvars */
|
if (!AGGREGATE_TYPE_P (TREE_TYPE (type))) /* var_can_have_subvars */
|
push = true;
|
push = true;
|
else if (!(pushed = push_fields_onto_fieldstack
|
else if (!(pushed = push_fields_onto_fieldstack
|
(TREE_TYPE (type), fieldstack,
|
(TREE_TYPE (type), fieldstack,
|
offset + i * TREE_INT_CST_LOW (elsz), has_union)))
|
offset + i * TREE_INT_CST_LOW (elsz), has_union)))
|
/* Empty structures may have actual size, like in C++. So
|
/* Empty structures may have actual size, like in C++. So
|
see if we didn't push any subfields and the size is
|
see if we didn't push any subfields and the size is
|
nonzero, push the field onto the stack */
|
nonzero, push the field onto the stack */
|
push = true;
|
push = true;
|
|
|
if (push)
|
if (push)
|
{
|
{
|
fieldoff_s *pair;
|
fieldoff_s *pair;
|
|
|
pair = VEC_safe_push (fieldoff_s, heap, *fieldstack, NULL);
|
pair = VEC_safe_push (fieldoff_s, heap, *fieldstack, NULL);
|
pair->type = TREE_TYPE (type);
|
pair->type = TREE_TYPE (type);
|
pair->size = elsz;
|
pair->size = elsz;
|
pair->decl = NULL_TREE;
|
pair->decl = NULL_TREE;
|
pair->offset = offset + i * TREE_INT_CST_LOW (elsz);
|
pair->offset = offset + i * TREE_INT_CST_LOW (elsz);
|
count++;
|
count++;
|
}
|
}
|
else
|
else
|
count += pushed;
|
count += pushed;
|
}
|
}
|
|
|
return count;
|
return count;
|
}
|
}
|
|
|
for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
|
for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
|
if (TREE_CODE (field) == FIELD_DECL)
|
if (TREE_CODE (field) == FIELD_DECL)
|
{
|
{
|
bool push = false;
|
bool push = false;
|
int pushed = 0;
|
int pushed = 0;
|
|
|
if (has_union
|
if (has_union
|
&& (TREE_CODE (TREE_TYPE (field)) == QUAL_UNION_TYPE
|
&& (TREE_CODE (TREE_TYPE (field)) == QUAL_UNION_TYPE
|
|| TREE_CODE (TREE_TYPE (field)) == UNION_TYPE))
|
|| TREE_CODE (TREE_TYPE (field)) == UNION_TYPE))
|
*has_union = true;
|
*has_union = true;
|
|
|
if (!var_can_have_subvars (field))
|
if (!var_can_have_subvars (field))
|
push = true;
|
push = true;
|
else if (!(pushed = push_fields_onto_fieldstack
|
else if (!(pushed = push_fields_onto_fieldstack
|
(TREE_TYPE (field), fieldstack,
|
(TREE_TYPE (field), fieldstack,
|
offset + bitpos_of_field (field), has_union))
|
offset + bitpos_of_field (field), has_union))
|
&& DECL_SIZE (field)
|
&& DECL_SIZE (field)
|
&& !integer_zerop (DECL_SIZE (field)))
|
&& !integer_zerop (DECL_SIZE (field)))
|
/* Empty structures may have actual size, like in C++. So
|
/* Empty structures may have actual size, like in C++. So
|
see if we didn't push any subfields and the size is
|
see if we didn't push any subfields and the size is
|
nonzero, push the field onto the stack */
|
nonzero, push the field onto the stack */
|
push = true;
|
push = true;
|
|
|
if (push)
|
if (push)
|
{
|
{
|
fieldoff_s *pair;
|
fieldoff_s *pair;
|
|
|
pair = VEC_safe_push (fieldoff_s, heap, *fieldstack, NULL);
|
pair = VEC_safe_push (fieldoff_s, heap, *fieldstack, NULL);
|
pair->type = TREE_TYPE (field);
|
pair->type = TREE_TYPE (field);
|
pair->size = DECL_SIZE (field);
|
pair->size = DECL_SIZE (field);
|
pair->decl = field;
|
pair->decl = field;
|
pair->offset = offset + bitpos_of_field (field);
|
pair->offset = offset + bitpos_of_field (field);
|
count++;
|
count++;
|
}
|
}
|
else
|
else
|
count += pushed;
|
count += pushed;
|
|
|
if (bitpos_of_field (field) < minoffset)
|
if (bitpos_of_field (field) < minoffset)
|
minoffset = bitpos_of_field (field);
|
minoffset = bitpos_of_field (field);
|
}
|
}
|
|
|
/* We need to create a fake subvar for empty bases. But _only_ for non-empty
|
/* We need to create a fake subvar for empty bases. But _only_ for non-empty
|
classes. */
|
classes. */
|
if (minoffset != 0 && count != 0)
|
if (minoffset != 0 && count != 0)
|
{
|
{
|
fieldoff_s *pair;
|
fieldoff_s *pair;
|
|
|
pair = VEC_safe_push (fieldoff_s, heap, *fieldstack, NULL);
|
pair = VEC_safe_push (fieldoff_s, heap, *fieldstack, NULL);
|
pair->type = void_type_node;
|
pair->type = void_type_node;
|
pair->size = build_int_cst (size_type_node, minoffset);
|
pair->size = build_int_cst (size_type_node, minoffset);
|
pair->decl = NULL;
|
pair->decl = NULL;
|
pair->offset = offset;
|
pair->offset = offset;
|
count++;
|
count++;
|
}
|
}
|
|
|
return count;
|
return count;
|
}
|
}
|
|
|
/* Create a constraint from ESCAPED_VARS variable to VI. */
|
/* Create a constraint from ESCAPED_VARS variable to VI. */
|
static void
|
static void
|
make_constraint_from_escaped (varinfo_t vi)
|
make_constraint_from_escaped (varinfo_t vi)
|
{
|
{
|
struct constraint_expr lhs, rhs;
|
struct constraint_expr lhs, rhs;
|
|
|
lhs.var = vi->id;
|
lhs.var = vi->id;
|
lhs.offset = 0;
|
lhs.offset = 0;
|
lhs.type = SCALAR;
|
lhs.type = SCALAR;
|
|
|
rhs.var = escaped_vars_id;
|
rhs.var = escaped_vars_id;
|
rhs.offset = 0;
|
rhs.offset = 0;
|
rhs.type = SCALAR;
|
rhs.type = SCALAR;
|
process_constraint (new_constraint (lhs, rhs));
|
process_constraint (new_constraint (lhs, rhs));
|
}
|
}
|
|
|
/* Create a constraint to the ESCAPED_VARS variable from constraint
|
/* Create a constraint to the ESCAPED_VARS variable from constraint
|
expression RHS. */
|
expression RHS. */
|
|
|
static void
|
static void
|
make_constraint_to_escaped (struct constraint_expr rhs)
|
make_constraint_to_escaped (struct constraint_expr rhs)
|
{
|
{
|
struct constraint_expr lhs;
|
struct constraint_expr lhs;
|
|
|
lhs.var = escaped_vars_id;
|
lhs.var = escaped_vars_id;
|
lhs.offset = 0;
|
lhs.offset = 0;
|
lhs.type = SCALAR;
|
lhs.type = SCALAR;
|
|
|
process_constraint (new_constraint (lhs, rhs));
|
process_constraint (new_constraint (lhs, rhs));
|
}
|
}
|
|
|
/* Count the number of arguments DECL has, and set IS_VARARGS to true
|
/* Count the number of arguments DECL has, and set IS_VARARGS to true
|
if it is a varargs function. */
|
if it is a varargs function. */
|
|
|
static unsigned int
|
static unsigned int
|
count_num_arguments (tree decl, bool *is_varargs)
|
count_num_arguments (tree decl, bool *is_varargs)
|
{
|
{
|
unsigned int i = 0;
|
unsigned int i = 0;
|
tree t;
|
tree t;
|
|
|
for (t = TYPE_ARG_TYPES (TREE_TYPE (decl));
|
for (t = TYPE_ARG_TYPES (TREE_TYPE (decl));
|
t;
|
t;
|
t = TREE_CHAIN (t))
|
t = TREE_CHAIN (t))
|
{
|
{
|
if (TREE_VALUE (t) == void_type_node)
|
if (TREE_VALUE (t) == void_type_node)
|
break;
|
break;
|
i++;
|
i++;
|
}
|
}
|
|
|
if (!t)
|
if (!t)
|
*is_varargs = true;
|
*is_varargs = true;
|
return i;
|
return i;
|
}
|
}
|
|
|
/* Creation function node for DECL, using NAME, and return the index
|
/* Creation function node for DECL, using NAME, and return the index
|
of the variable we've created for the function. */
|
of the variable we've created for the function. */
|
|
|
static unsigned int
|
static unsigned int
|
create_function_info_for (tree decl, const char *name)
|
create_function_info_for (tree decl, const char *name)
|
{
|
{
|
unsigned int index = VEC_length (varinfo_t, varmap);
|
unsigned int index = VEC_length (varinfo_t, varmap);
|
varinfo_t vi;
|
varinfo_t vi;
|
tree arg;
|
tree arg;
|
unsigned int i;
|
unsigned int i;
|
bool is_varargs = false;
|
bool is_varargs = false;
|
|
|
/* Create the variable info. */
|
/* Create the variable info. */
|
|
|
vi = new_var_info (decl, index, name);
|
vi = new_var_info (decl, index, name);
|
vi->decl = decl;
|
vi->decl = decl;
|
vi->offset = 0;
|
vi->offset = 0;
|
vi->has_union = 0;
|
vi->has_union = 0;
|
vi->size = 1;
|
vi->size = 1;
|
vi->fullsize = count_num_arguments (decl, &is_varargs) + 1;
|
vi->fullsize = count_num_arguments (decl, &is_varargs) + 1;
|
insert_vi_for_tree (vi->decl, vi);
|
insert_vi_for_tree (vi->decl, vi);
|
VEC_safe_push (varinfo_t, heap, varmap, vi);
|
VEC_safe_push (varinfo_t, heap, varmap, vi);
|
|
|
stats.total_vars++;
|
stats.total_vars++;
|
|
|
/* If it's varargs, we don't know how many arguments it has, so we
|
/* If it's varargs, we don't know how many arguments it has, so we
|
can't do much.
|
can't do much.
|
*/
|
*/
|
if (is_varargs)
|
if (is_varargs)
|
{
|
{
|
vi->fullsize = ~0;
|
vi->fullsize = ~0;
|
vi->size = ~0;
|
vi->size = ~0;
|
vi->is_unknown_size_var = true;
|
vi->is_unknown_size_var = true;
|
return index;
|
return index;
|
}
|
}
|
|
|
|
|
arg = DECL_ARGUMENTS (decl);
|
arg = DECL_ARGUMENTS (decl);
|
|
|
/* Set up variables for each argument. */
|
/* Set up variables for each argument. */
|
for (i = 1; i < vi->fullsize; i++)
|
for (i = 1; i < vi->fullsize; i++)
|
{
|
{
|
varinfo_t argvi;
|
varinfo_t argvi;
|
const char *newname;
|
const char *newname;
|
char *tempname;
|
char *tempname;
|
unsigned int newindex;
|
unsigned int newindex;
|
tree argdecl = decl;
|
tree argdecl = decl;
|
|
|
if (arg)
|
if (arg)
|
argdecl = arg;
|
argdecl = arg;
|
|
|
newindex = VEC_length (varinfo_t, varmap);
|
newindex = VEC_length (varinfo_t, varmap);
|
asprintf (&tempname, "%s.arg%d", name, i-1);
|
asprintf (&tempname, "%s.arg%d", name, i-1);
|
newname = ggc_strdup (tempname);
|
newname = ggc_strdup (tempname);
|
free (tempname);
|
free (tempname);
|
|
|
argvi = new_var_info (argdecl, newindex, newname);
|
argvi = new_var_info (argdecl, newindex, newname);
|
argvi->decl = argdecl;
|
argvi->decl = argdecl;
|
VEC_safe_push (varinfo_t, heap, varmap, argvi);
|
VEC_safe_push (varinfo_t, heap, varmap, argvi);
|
argvi->offset = i;
|
argvi->offset = i;
|
argvi->size = 1;
|
argvi->size = 1;
|
argvi->fullsize = vi->fullsize;
|
argvi->fullsize = vi->fullsize;
|
argvi->has_union = false;
|
argvi->has_union = false;
|
insert_into_field_list_sorted (vi, argvi);
|
insert_into_field_list_sorted (vi, argvi);
|
stats.total_vars ++;
|
stats.total_vars ++;
|
if (arg)
|
if (arg)
|
{
|
{
|
insert_vi_for_tree (arg, argvi);
|
insert_vi_for_tree (arg, argvi);
|
arg = TREE_CHAIN (arg);
|
arg = TREE_CHAIN (arg);
|
}
|
}
|
}
|
}
|
|
|
/* Create a variable for the return var. */
|
/* Create a variable for the return var. */
|
if (DECL_RESULT (decl) != NULL
|
if (DECL_RESULT (decl) != NULL
|
|| !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
|
|| !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
|
{
|
{
|
varinfo_t resultvi;
|
varinfo_t resultvi;
|
const char *newname;
|
const char *newname;
|
char *tempname;
|
char *tempname;
|
unsigned int newindex;
|
unsigned int newindex;
|
tree resultdecl = decl;
|
tree resultdecl = decl;
|
|
|
vi->fullsize ++;
|
vi->fullsize ++;
|
|
|
if (DECL_RESULT (decl))
|
if (DECL_RESULT (decl))
|
resultdecl = DECL_RESULT (decl);
|
resultdecl = DECL_RESULT (decl);
|
|
|
newindex = VEC_length (varinfo_t, varmap);
|
newindex = VEC_length (varinfo_t, varmap);
|
asprintf (&tempname, "%s.result", name);
|
asprintf (&tempname, "%s.result", name);
|
newname = ggc_strdup (tempname);
|
newname = ggc_strdup (tempname);
|
free (tempname);
|
free (tempname);
|
|
|
resultvi = new_var_info (resultdecl, newindex, newname);
|
resultvi = new_var_info (resultdecl, newindex, newname);
|
resultvi->decl = resultdecl;
|
resultvi->decl = resultdecl;
|
VEC_safe_push (varinfo_t, heap, varmap, resultvi);
|
VEC_safe_push (varinfo_t, heap, varmap, resultvi);
|
resultvi->offset = i;
|
resultvi->offset = i;
|
resultvi->size = 1;
|
resultvi->size = 1;
|
resultvi->fullsize = vi->fullsize;
|
resultvi->fullsize = vi->fullsize;
|
resultvi->has_union = false;
|
resultvi->has_union = false;
|
insert_into_field_list_sorted (vi, resultvi);
|
insert_into_field_list_sorted (vi, resultvi);
|
stats.total_vars ++;
|
stats.total_vars ++;
|
if (DECL_RESULT (decl))
|
if (DECL_RESULT (decl))
|
insert_vi_for_tree (DECL_RESULT (decl), resultvi);
|
insert_vi_for_tree (DECL_RESULT (decl), resultvi);
|
}
|
}
|
return index;
|
return index;
|
}
|
}
|
|
|
|
|
/* Return true if FIELDSTACK contains fields that overlap.
|
/* Return true if FIELDSTACK contains fields that overlap.
|
FIELDSTACK is assumed to be sorted by offset. */
|
FIELDSTACK is assumed to be sorted by offset. */
|
|
|
static bool
|
static bool
|
check_for_overlaps (VEC (fieldoff_s,heap) *fieldstack)
|
check_for_overlaps (VEC (fieldoff_s,heap) *fieldstack)
|
{
|
{
|
fieldoff_s *fo = NULL;
|
fieldoff_s *fo = NULL;
|
unsigned int i;
|
unsigned int i;
|
HOST_WIDE_INT lastoffset = -1;
|
HOST_WIDE_INT lastoffset = -1;
|
|
|
for (i = 0; VEC_iterate (fieldoff_s, fieldstack, i, fo); i++)
|
for (i = 0; VEC_iterate (fieldoff_s, fieldstack, i, fo); i++)
|
{
|
{
|
if (fo->offset == lastoffset)
|
if (fo->offset == lastoffset)
|
return true;
|
return true;
|
lastoffset = fo->offset;
|
lastoffset = fo->offset;
|
}
|
}
|
return false;
|
return false;
|
}
|
}
|
|
|
/* This function is called through walk_tree to walk global
|
/* This function is called through walk_tree to walk global
|
initializers looking for constraints we need to add to the
|
initializers looking for constraints we need to add to the
|
constraint list. */
|
constraint list. */
|
|
|
static tree
|
static tree
|
find_global_initializers (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
|
find_global_initializers (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
|
void *viv)
|
void *viv)
|
{
|
{
|
varinfo_t vi = (varinfo_t)viv;
|
varinfo_t vi = (varinfo_t)viv;
|
tree t = *tp;
|
tree t = *tp;
|
|
|
switch (TREE_CODE (t))
|
switch (TREE_CODE (t))
|
{
|
{
|
/* Dereferences and addressofs are the only important things
|
/* Dereferences and addressofs are the only important things
|
here, and i don't even remember if dereferences are legal
|
here, and i don't even remember if dereferences are legal
|
here in initializers. */
|
here in initializers. */
|
case INDIRECT_REF:
|
case INDIRECT_REF:
|
case ADDR_EXPR:
|
case ADDR_EXPR:
|
{
|
{
|
struct constraint_expr *c;
|
struct constraint_expr *c;
|
size_t i;
|
size_t i;
|
|
|
VEC(ce_s, heap) *rhsc = NULL;
|
VEC(ce_s, heap) *rhsc = NULL;
|
get_constraint_for (t, &rhsc);
|
get_constraint_for (t, &rhsc);
|
for (i = 0; VEC_iterate (ce_s, rhsc, i, c); i++)
|
for (i = 0; VEC_iterate (ce_s, rhsc, i, c); i++)
|
{
|
{
|
struct constraint_expr lhs;
|
struct constraint_expr lhs;
|
|
|
lhs.var = vi->id;
|
lhs.var = vi->id;
|
lhs.type = SCALAR;
|
lhs.type = SCALAR;
|
lhs.offset = 0;
|
lhs.offset = 0;
|
process_constraint (new_constraint (lhs, *c));
|
process_constraint (new_constraint (lhs, *c));
|
}
|
}
|
|
|
VEC_free (ce_s, heap, rhsc);
|
VEC_free (ce_s, heap, rhsc);
|
}
|
}
|
break;
|
break;
|
case VAR_DECL:
|
case VAR_DECL:
|
/* We might not have walked this because we skip
|
/* We might not have walked this because we skip
|
DECL_EXTERNALs during the initial scan. */
|
DECL_EXTERNALs during the initial scan. */
|
if (referenced_vars)
|
if (referenced_vars)
|
{
|
{
|
get_var_ann (t);
|
get_var_ann (t);
|
if (referenced_var_check_and_insert (t))
|
if (referenced_var_check_and_insert (t))
|
mark_sym_for_renaming (t);
|
mark_sym_for_renaming (t);
|
}
|
}
|
break;
|
break;
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Create a varinfo structure for NAME and DECL, and add it to VARMAP.
|
/* Create a varinfo structure for NAME and DECL, and add it to VARMAP.
|
This will also create any varinfo structures necessary for fields
|
This will also create any varinfo structures necessary for fields
|
of DECL. */
|
of DECL. */
|
|
|
static unsigned int
|
static unsigned int
|
create_variable_info_for (tree decl, const char *name)
|
create_variable_info_for (tree decl, const char *name)
|
{
|
{
|
unsigned int index = VEC_length (varinfo_t, varmap);
|
unsigned int index = VEC_length (varinfo_t, varmap);
|
varinfo_t vi;
|
varinfo_t vi;
|
tree decltype = TREE_TYPE (decl);
|
tree decltype = TREE_TYPE (decl);
|
tree declsize = DECL_P (decl) ? DECL_SIZE (decl) : TYPE_SIZE (decltype);
|
tree declsize = DECL_P (decl) ? DECL_SIZE (decl) : TYPE_SIZE (decltype);
|
bool notokay = false;
|
bool notokay = false;
|
bool hasunion;
|
bool hasunion;
|
bool is_global = DECL_P (decl) ? is_global_var (decl) : false;
|
bool is_global = DECL_P (decl) ? is_global_var (decl) : false;
|
VEC (fieldoff_s,heap) *fieldstack = NULL;
|
VEC (fieldoff_s,heap) *fieldstack = NULL;
|
|
|
if (TREE_CODE (decl) == FUNCTION_DECL && in_ipa_mode)
|
if (TREE_CODE (decl) == FUNCTION_DECL && in_ipa_mode)
|
return create_function_info_for (decl, name);
|
return create_function_info_for (decl, name);
|
|
|
hasunion = TREE_CODE (decltype) == UNION_TYPE
|
hasunion = TREE_CODE (decltype) == UNION_TYPE
|
|| TREE_CODE (decltype) == QUAL_UNION_TYPE;
|
|| TREE_CODE (decltype) == QUAL_UNION_TYPE;
|
if (var_can_have_subvars (decl) && use_field_sensitive && !hasunion)
|
if (var_can_have_subvars (decl) && use_field_sensitive && !hasunion)
|
{
|
{
|
push_fields_onto_fieldstack (decltype, &fieldstack, 0, &hasunion);
|
push_fields_onto_fieldstack (decltype, &fieldstack, 0, &hasunion);
|
if (hasunion)
|
if (hasunion)
|
{
|
{
|
VEC_free (fieldoff_s, heap, fieldstack);
|
VEC_free (fieldoff_s, heap, fieldstack);
|
notokay = true;
|
notokay = true;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* If the variable doesn't have subvars, we may end up needing to
|
/* If the variable doesn't have subvars, we may end up needing to
|
sort the field list and create fake variables for all the
|
sort the field list and create fake variables for all the
|
fields. */
|
fields. */
|
vi = new_var_info (decl, index, name);
|
vi = new_var_info (decl, index, name);
|
vi->decl = decl;
|
vi->decl = decl;
|
vi->offset = 0;
|
vi->offset = 0;
|
vi->has_union = hasunion;
|
vi->has_union = hasunion;
|
if (!declsize
|
if (!declsize
|
|| TREE_CODE (declsize) != INTEGER_CST
|
|| TREE_CODE (declsize) != INTEGER_CST
|
|| TREE_CODE (decltype) == UNION_TYPE
|
|| TREE_CODE (decltype) == UNION_TYPE
|
|| TREE_CODE (decltype) == QUAL_UNION_TYPE)
|
|| TREE_CODE (decltype) == QUAL_UNION_TYPE)
|
{
|
{
|
vi->is_unknown_size_var = true;
|
vi->is_unknown_size_var = true;
|
vi->fullsize = ~0;
|
vi->fullsize = ~0;
|
vi->size = ~0;
|
vi->size = ~0;
|
}
|
}
|
else
|
else
|
{
|
{
|
vi->fullsize = TREE_INT_CST_LOW (declsize);
|
vi->fullsize = TREE_INT_CST_LOW (declsize);
|
vi->size = vi->fullsize;
|
vi->size = vi->fullsize;
|
}
|
}
|
|
|
insert_vi_for_tree (vi->decl, vi);
|
insert_vi_for_tree (vi->decl, vi);
|
VEC_safe_push (varinfo_t, heap, varmap, vi);
|
VEC_safe_push (varinfo_t, heap, varmap, vi);
|
if (is_global && (!flag_whole_program || !in_ipa_mode))
|
if (is_global && (!flag_whole_program || !in_ipa_mode))
|
{
|
{
|
make_constraint_from_escaped (vi);
|
make_constraint_from_escaped (vi);
|
|
|
/* If the variable can't be aliased, there is no point in
|
/* If the variable can't be aliased, there is no point in
|
putting it in the set of nonlocal vars. */
|
putting it in the set of nonlocal vars. */
|
if (may_be_aliased (vi->decl))
|
if (may_be_aliased (vi->decl))
|
{
|
{
|
struct constraint_expr rhs;
|
struct constraint_expr rhs;
|
rhs.var = index;
|
rhs.var = index;
|
rhs.type = ADDRESSOF;
|
rhs.type = ADDRESSOF;
|
rhs.offset = 0;
|
rhs.offset = 0;
|
make_constraint_to_escaped (rhs);
|
make_constraint_to_escaped (rhs);
|
}
|
}
|
|
|
if (TREE_CODE (decl) != FUNCTION_DECL && DECL_INITIAL (decl))
|
if (TREE_CODE (decl) != FUNCTION_DECL && DECL_INITIAL (decl))
|
{
|
{
|
walk_tree_without_duplicates (&DECL_INITIAL (decl),
|
walk_tree_without_duplicates (&DECL_INITIAL (decl),
|
find_global_initializers,
|
find_global_initializers,
|
(void *)vi);
|
(void *)vi);
|
}
|
}
|
}
|
}
|
|
|
stats.total_vars++;
|
stats.total_vars++;
|
if (use_field_sensitive
|
if (use_field_sensitive
|
&& !notokay
|
&& !notokay
|
&& !vi->is_unknown_size_var
|
&& !vi->is_unknown_size_var
|
&& var_can_have_subvars (decl)
|
&& var_can_have_subvars (decl)
|
&& VEC_length (fieldoff_s, fieldstack) <= MAX_FIELDS_FOR_FIELD_SENSITIVE)
|
&& VEC_length (fieldoff_s, fieldstack) <= MAX_FIELDS_FOR_FIELD_SENSITIVE)
|
{
|
{
|
unsigned int newindex = VEC_length (varinfo_t, varmap);
|
unsigned int newindex = VEC_length (varinfo_t, varmap);
|
fieldoff_s *fo = NULL;
|
fieldoff_s *fo = NULL;
|
unsigned int i;
|
unsigned int i;
|
|
|
for (i = 0; !notokay && VEC_iterate (fieldoff_s, fieldstack, i, fo); i++)
|
for (i = 0; !notokay && VEC_iterate (fieldoff_s, fieldstack, i, fo); i++)
|
{
|
{
|
if (! fo->size
|
if (! fo->size
|
|| TREE_CODE (fo->size) != INTEGER_CST
|
|| TREE_CODE (fo->size) != INTEGER_CST
|
|| fo->offset < 0)
|
|| fo->offset < 0)
|
{
|
{
|
notokay = true;
|
notokay = true;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
/* We can't sort them if we have a field with a variable sized type,
|
/* We can't sort them if we have a field with a variable sized type,
|
which will make notokay = true. In that case, we are going to return
|
which will make notokay = true. In that case, we are going to return
|
without creating varinfos for the fields anyway, so sorting them is a
|
without creating varinfos for the fields anyway, so sorting them is a
|
waste to boot. */
|
waste to boot. */
|
if (!notokay)
|
if (!notokay)
|
{
|
{
|
sort_fieldstack (fieldstack);
|
sort_fieldstack (fieldstack);
|
/* Due to some C++ FE issues, like PR 22488, we might end up
|
/* Due to some C++ FE issues, like PR 22488, we might end up
|
what appear to be overlapping fields even though they,
|
what appear to be overlapping fields even though they,
|
in reality, do not overlap. Until the C++ FE is fixed,
|
in reality, do not overlap. Until the C++ FE is fixed,
|
we will simply disable field-sensitivity for these cases. */
|
we will simply disable field-sensitivity for these cases. */
|
notokay = check_for_overlaps (fieldstack);
|
notokay = check_for_overlaps (fieldstack);
|
}
|
}
|
|
|
|
|
if (VEC_length (fieldoff_s, fieldstack) != 0)
|
if (VEC_length (fieldoff_s, fieldstack) != 0)
|
fo = VEC_index (fieldoff_s, fieldstack, 0);
|
fo = VEC_index (fieldoff_s, fieldstack, 0);
|
|
|
if (fo == NULL || notokay)
|
if (fo == NULL || notokay)
|
{
|
{
|
vi->is_unknown_size_var = 1;
|
vi->is_unknown_size_var = 1;
|
vi->fullsize = ~0;
|
vi->fullsize = ~0;
|
vi->size = ~0;
|
vi->size = ~0;
|
VEC_free (fieldoff_s, heap, fieldstack);
|
VEC_free (fieldoff_s, heap, fieldstack);
|
return index;
|
return index;
|
}
|
}
|
|
|
vi->size = TREE_INT_CST_LOW (fo->size);
|
vi->size = TREE_INT_CST_LOW (fo->size);
|
vi->offset = fo->offset;
|
vi->offset = fo->offset;
|
for (i = VEC_length (fieldoff_s, fieldstack) - 1;
|
for (i = VEC_length (fieldoff_s, fieldstack) - 1;
|
i >= 1 && VEC_iterate (fieldoff_s, fieldstack, i, fo);
|
i >= 1 && VEC_iterate (fieldoff_s, fieldstack, i, fo);
|
i--)
|
i--)
|
{
|
{
|
varinfo_t newvi;
|
varinfo_t newvi;
|
const char *newname = "NULL";
|
const char *newname = "NULL";
|
char *tempname;
|
char *tempname;
|
|
|
newindex = VEC_length (varinfo_t, varmap);
|
newindex = VEC_length (varinfo_t, varmap);
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
if (fo->decl)
|
if (fo->decl)
|
asprintf (&tempname, "%s.%s",
|
asprintf (&tempname, "%s.%s",
|
vi->name, alias_get_name (fo->decl));
|
vi->name, alias_get_name (fo->decl));
|
else
|
else
|
asprintf (&tempname, "%s." HOST_WIDE_INT_PRINT_DEC,
|
asprintf (&tempname, "%s." HOST_WIDE_INT_PRINT_DEC,
|
vi->name, fo->offset);
|
vi->name, fo->offset);
|
newname = ggc_strdup (tempname);
|
newname = ggc_strdup (tempname);
|
free (tempname);
|
free (tempname);
|
}
|
}
|
newvi = new_var_info (decl, newindex, newname);
|
newvi = new_var_info (decl, newindex, newname);
|
newvi->offset = fo->offset;
|
newvi->offset = fo->offset;
|
newvi->size = TREE_INT_CST_LOW (fo->size);
|
newvi->size = TREE_INT_CST_LOW (fo->size);
|
newvi->fullsize = vi->fullsize;
|
newvi->fullsize = vi->fullsize;
|
insert_into_field_list (vi, newvi);
|
insert_into_field_list (vi, newvi);
|
VEC_safe_push (varinfo_t, heap, varmap, newvi);
|
VEC_safe_push (varinfo_t, heap, varmap, newvi);
|
if (is_global && (!flag_whole_program || !in_ipa_mode))
|
if (is_global && (!flag_whole_program || !in_ipa_mode))
|
{
|
{
|
/* If the variable can't be aliased, there is no point in
|
/* If the variable can't be aliased, there is no point in
|
putting it in the set of nonlocal vars. */
|
putting it in the set of nonlocal vars. */
|
if (may_be_aliased (vi->decl))
|
if (may_be_aliased (vi->decl))
|
{
|
{
|
struct constraint_expr rhs;
|
struct constraint_expr rhs;
|
|
|
rhs.var = newindex;
|
rhs.var = newindex;
|
rhs.type = ADDRESSOF;
|
rhs.type = ADDRESSOF;
|
rhs.offset = 0;
|
rhs.offset = 0;
|
make_constraint_to_escaped (rhs);
|
make_constraint_to_escaped (rhs);
|
}
|
}
|
make_constraint_from_escaped (newvi);
|
make_constraint_from_escaped (newvi);
|
}
|
}
|
|
|
stats.total_vars++;
|
stats.total_vars++;
|
}
|
}
|
VEC_free (fieldoff_s, heap, fieldstack);
|
VEC_free (fieldoff_s, heap, fieldstack);
|
}
|
}
|
return index;
|
return index;
|
}
|
}
|
|
|
/* Print out the points-to solution for VAR to FILE. */
|
/* Print out the points-to solution for VAR to FILE. */
|
|
|
void
|
void
|
dump_solution_for_var (FILE *file, unsigned int var)
|
dump_solution_for_var (FILE *file, unsigned int var)
|
{
|
{
|
varinfo_t vi = get_varinfo (var);
|
varinfo_t vi = get_varinfo (var);
|
unsigned int i;
|
unsigned int i;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
|
|
if (find (var) != var)
|
if (find (var) != var)
|
{
|
{
|
varinfo_t vipt = get_varinfo (find (var));
|
varinfo_t vipt = get_varinfo (find (var));
|
fprintf (file, "%s = same as %s\n", vi->name, vipt->name);
|
fprintf (file, "%s = same as %s\n", vi->name, vipt->name);
|
}
|
}
|
else
|
else
|
{
|
{
|
fprintf (file, "%s = { ", vi->name);
|
fprintf (file, "%s = { ", vi->name);
|
EXECUTE_IF_SET_IN_BITMAP (vi->solution, 0, i, bi)
|
EXECUTE_IF_SET_IN_BITMAP (vi->solution, 0, i, bi)
|
{
|
{
|
fprintf (file, "%s ", get_varinfo (i)->name);
|
fprintf (file, "%s ", get_varinfo (i)->name);
|
}
|
}
|
fprintf (file, "}\n");
|
fprintf (file, "}\n");
|
}
|
}
|
}
|
}
|
|
|
/* Print the points-to solution for VAR to stdout. */
|
/* Print the points-to solution for VAR to stdout. */
|
|
|
void
|
void
|
debug_solution_for_var (unsigned int var)
|
debug_solution_for_var (unsigned int var)
|
{
|
{
|
dump_solution_for_var (stdout, var);
|
dump_solution_for_var (stdout, var);
|
}
|
}
|
|
|
/* Create varinfo structures for all of the variables in the
|
/* Create varinfo structures for all of the variables in the
|
function for intraprocedural mode. */
|
function for intraprocedural mode. */
|
|
|
static void
|
static void
|
intra_create_variable_infos (void)
|
intra_create_variable_infos (void)
|
{
|
{
|
tree t;
|
tree t;
|
struct constraint_expr lhs, rhs;
|
struct constraint_expr lhs, rhs;
|
varinfo_t nonlocal_vi;
|
varinfo_t nonlocal_vi;
|
|
|
/* For each incoming pointer argument arg, ARG = ESCAPED_VARS or a
|
/* For each incoming pointer argument arg, ARG = ESCAPED_VARS or a
|
dummy variable if flag_argument_noalias > 2. */
|
dummy variable if flag_argument_noalias > 2. */
|
for (t = DECL_ARGUMENTS (current_function_decl); t; t = TREE_CHAIN (t))
|
for (t = DECL_ARGUMENTS (current_function_decl); t; t = TREE_CHAIN (t))
|
{
|
{
|
varinfo_t p;
|
varinfo_t p;
|
unsigned int arg_id;
|
unsigned int arg_id;
|
|
|
if (!could_have_pointers (t))
|
if (!could_have_pointers (t))
|
continue;
|
continue;
|
|
|
arg_id = get_vi_for_tree (t)->id;
|
arg_id = get_vi_for_tree (t)->id;
|
|
|
/* With flag_argument_noalias greater than two means that the incoming
|
/* With flag_argument_noalias greater than two means that the incoming
|
argument cannot alias anything except for itself so create a HEAP
|
argument cannot alias anything except for itself so create a HEAP
|
variable. */
|
variable. */
|
if (POINTER_TYPE_P (TREE_TYPE (t))
|
if (POINTER_TYPE_P (TREE_TYPE (t))
|
&& flag_argument_noalias > 2)
|
&& flag_argument_noalias > 2)
|
{
|
{
|
varinfo_t vi;
|
varinfo_t vi;
|
tree heapvar = heapvar_lookup (t);
|
tree heapvar = heapvar_lookup (t);
|
|
|
lhs.offset = 0;
|
lhs.offset = 0;
|
lhs.type = SCALAR;
|
lhs.type = SCALAR;
|
lhs.var = get_vi_for_tree (t)->id;
|
lhs.var = get_vi_for_tree (t)->id;
|
|
|
if (heapvar == NULL_TREE)
|
if (heapvar == NULL_TREE)
|
{
|
{
|
heapvar = create_tmp_var_raw (TREE_TYPE (TREE_TYPE (t)),
|
heapvar = create_tmp_var_raw (TREE_TYPE (TREE_TYPE (t)),
|
"PARM_NOALIAS");
|
"PARM_NOALIAS");
|
DECL_EXTERNAL (heapvar) = 1;
|
DECL_EXTERNAL (heapvar) = 1;
|
if (referenced_vars)
|
if (referenced_vars)
|
add_referenced_var (heapvar);
|
add_referenced_var (heapvar);
|
heapvar_insert (t, heapvar);
|
heapvar_insert (t, heapvar);
|
}
|
}
|
|
|
vi = get_vi_for_tree (heapvar);
|
vi = get_vi_for_tree (heapvar);
|
vi->is_artificial_var = 1;
|
vi->is_artificial_var = 1;
|
vi->is_heap_var = 1;
|
vi->is_heap_var = 1;
|
rhs.var = vi->id;
|
rhs.var = vi->id;
|
rhs.type = ADDRESSOF;
|
rhs.type = ADDRESSOF;
|
rhs.offset = 0;
|
rhs.offset = 0;
|
for (p = get_varinfo (lhs.var); p; p = p->next)
|
for (p = get_varinfo (lhs.var); p; p = p->next)
|
{
|
{
|
struct constraint_expr temp = lhs;
|
struct constraint_expr temp = lhs;
|
temp.var = p->id;
|
temp.var = p->id;
|
process_constraint (new_constraint (temp, rhs));
|
process_constraint (new_constraint (temp, rhs));
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
for (p = get_varinfo (arg_id); p; p = p->next)
|
for (p = get_varinfo (arg_id); p; p = p->next)
|
make_constraint_from_escaped (p);
|
make_constraint_from_escaped (p);
|
}
|
}
|
}
|
}
|
if (!nonlocal_all)
|
if (!nonlocal_all)
|
nonlocal_all = create_nonlocal_var (void_type_node);
|
nonlocal_all = create_nonlocal_var (void_type_node);
|
|
|
/* Create variable info for the nonlocal var if it does not
|
/* Create variable info for the nonlocal var if it does not
|
exist. */
|
exist. */
|
nonlocal_vars_id = create_variable_info_for (nonlocal_all,
|
nonlocal_vars_id = create_variable_info_for (nonlocal_all,
|
get_name (nonlocal_all));
|
get_name (nonlocal_all));
|
nonlocal_vi = get_varinfo (nonlocal_vars_id);
|
nonlocal_vi = get_varinfo (nonlocal_vars_id);
|
nonlocal_vi->is_artificial_var = 1;
|
nonlocal_vi->is_artificial_var = 1;
|
nonlocal_vi->is_heap_var = 1;
|
nonlocal_vi->is_heap_var = 1;
|
nonlocal_vi->is_unknown_size_var = 1;
|
nonlocal_vi->is_unknown_size_var = 1;
|
nonlocal_vi->directly_dereferenced = true;
|
nonlocal_vi->directly_dereferenced = true;
|
|
|
rhs.var = nonlocal_vars_id;
|
rhs.var = nonlocal_vars_id;
|
rhs.type = ADDRESSOF;
|
rhs.type = ADDRESSOF;
|
rhs.offset = 0;
|
rhs.offset = 0;
|
|
|
lhs.var = escaped_vars_id;
|
lhs.var = escaped_vars_id;
|
lhs.type = SCALAR;
|
lhs.type = SCALAR;
|
lhs.offset = 0;
|
lhs.offset = 0;
|
|
|
process_constraint (new_constraint (lhs, rhs));
|
process_constraint (new_constraint (lhs, rhs));
|
}
|
}
|
|
|
/* Structure used to put solution bitmaps in a hashtable so they can
|
/* Structure used to put solution bitmaps in a hashtable so they can
|
be shared among variables with the same points-to set. */
|
be shared among variables with the same points-to set. */
|
|
|
typedef struct shared_bitmap_info
|
typedef struct shared_bitmap_info
|
{
|
{
|
bitmap pt_vars;
|
bitmap pt_vars;
|
hashval_t hashcode;
|
hashval_t hashcode;
|
} *shared_bitmap_info_t;
|
} *shared_bitmap_info_t;
|
|
|
static htab_t shared_bitmap_table;
|
static htab_t shared_bitmap_table;
|
|
|
/* Hash function for a shared_bitmap_info_t */
|
/* Hash function for a shared_bitmap_info_t */
|
|
|
static hashval_t
|
static hashval_t
|
shared_bitmap_hash (const void *p)
|
shared_bitmap_hash (const void *p)
|
{
|
{
|
const shared_bitmap_info_t bi = (shared_bitmap_info_t) p;
|
const shared_bitmap_info_t bi = (shared_bitmap_info_t) p;
|
return bi->hashcode;
|
return bi->hashcode;
|
}
|
}
|
|
|
/* Equality function for two shared_bitmap_info_t's. */
|
/* Equality function for two shared_bitmap_info_t's. */
|
|
|
static int
|
static int
|
shared_bitmap_eq (const void *p1, const void *p2)
|
shared_bitmap_eq (const void *p1, const void *p2)
|
{
|
{
|
const shared_bitmap_info_t sbi1 = (shared_bitmap_info_t) p1;
|
const shared_bitmap_info_t sbi1 = (shared_bitmap_info_t) p1;
|
const shared_bitmap_info_t sbi2 = (shared_bitmap_info_t) p2;
|
const shared_bitmap_info_t sbi2 = (shared_bitmap_info_t) p2;
|
return bitmap_equal_p (sbi1->pt_vars, sbi2->pt_vars);
|
return bitmap_equal_p (sbi1->pt_vars, sbi2->pt_vars);
|
}
|
}
|
|
|
/* Lookup a bitmap in the shared bitmap hashtable, and return an already
|
/* Lookup a bitmap in the shared bitmap hashtable, and return an already
|
existing instance if there is one, NULL otherwise. */
|
existing instance if there is one, NULL otherwise. */
|
|
|
static bitmap
|
static bitmap
|
shared_bitmap_lookup (bitmap pt_vars)
|
shared_bitmap_lookup (bitmap pt_vars)
|
{
|
{
|
void **slot;
|
void **slot;
|
struct shared_bitmap_info sbi;
|
struct shared_bitmap_info sbi;
|
|
|
sbi.pt_vars = pt_vars;
|
sbi.pt_vars = pt_vars;
|
sbi.hashcode = bitmap_hash (pt_vars);
|
sbi.hashcode = bitmap_hash (pt_vars);
|
|
|
slot = htab_find_slot_with_hash (shared_bitmap_table, &sbi,
|
slot = htab_find_slot_with_hash (shared_bitmap_table, &sbi,
|
sbi.hashcode, NO_INSERT);
|
sbi.hashcode, NO_INSERT);
|
if (!slot)
|
if (!slot)
|
return NULL;
|
return NULL;
|
else
|
else
|
return ((shared_bitmap_info_t) *slot)->pt_vars;
|
return ((shared_bitmap_info_t) *slot)->pt_vars;
|
}
|
}
|
|
|
|
|
/* Add a bitmap to the shared bitmap hashtable. */
|
/* Add a bitmap to the shared bitmap hashtable. */
|
|
|
static void
|
static void
|
shared_bitmap_add (bitmap pt_vars)
|
shared_bitmap_add (bitmap pt_vars)
|
{
|
{
|
void **slot;
|
void **slot;
|
shared_bitmap_info_t sbi = XNEW (struct shared_bitmap_info);
|
shared_bitmap_info_t sbi = XNEW (struct shared_bitmap_info);
|
|
|
sbi->pt_vars = pt_vars;
|
sbi->pt_vars = pt_vars;
|
sbi->hashcode = bitmap_hash (pt_vars);
|
sbi->hashcode = bitmap_hash (pt_vars);
|
|
|
slot = htab_find_slot_with_hash (shared_bitmap_table, sbi,
|
slot = htab_find_slot_with_hash (shared_bitmap_table, sbi,
|
sbi->hashcode, INSERT);
|
sbi->hashcode, INSERT);
|
gcc_assert (!*slot);
|
gcc_assert (!*slot);
|
*slot = (void *) sbi;
|
*slot = (void *) sbi;
|
}
|
}
|
|
|
|
|
/* Set bits in INTO corresponding to the variable uids in solution set
|
/* Set bits in INTO corresponding to the variable uids in solution set
|
FROM, which came from variable PTR.
|
FROM, which came from variable PTR.
|
For variables that are actually dereferenced, we also use type
|
For variables that are actually dereferenced, we also use type
|
based alias analysis to prune the points-to sets. */
|
based alias analysis to prune the points-to sets. */
|
|
|
static void
|
static void
|
set_uids_in_ptset (tree ptr, bitmap into, bitmap from)
|
set_uids_in_ptset (tree ptr, bitmap into, bitmap from)
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
subvar_t sv;
|
subvar_t sv;
|
unsigned HOST_WIDE_INT ptr_alias_set = get_alias_set (TREE_TYPE (ptr));
|
unsigned HOST_WIDE_INT ptr_alias_set = get_alias_set (TREE_TYPE (ptr));
|
|
|
EXECUTE_IF_SET_IN_BITMAP (from, 0, i, bi)
|
EXECUTE_IF_SET_IN_BITMAP (from, 0, i, bi)
|
{
|
{
|
varinfo_t vi = get_varinfo (i);
|
varinfo_t vi = get_varinfo (i);
|
unsigned HOST_WIDE_INT var_alias_set;
|
unsigned HOST_WIDE_INT var_alias_set;
|
|
|
/* The only artificial variables that are allowed in a may-alias
|
/* The only artificial variables that are allowed in a may-alias
|
set are heap variables. */
|
set are heap variables. */
|
if (vi->is_artificial_var && !vi->is_heap_var)
|
if (vi->is_artificial_var && !vi->is_heap_var)
|
continue;
|
continue;
|
|
|
if (vi->has_union && get_subvars_for_var (vi->decl) != NULL)
|
if (vi->has_union && get_subvars_for_var (vi->decl) != NULL)
|
{
|
{
|
/* Variables containing unions may need to be converted to
|
/* Variables containing unions may need to be converted to
|
their SFT's, because SFT's can have unions and we cannot. */
|
their SFT's, because SFT's can have unions and we cannot. */
|
for (sv = get_subvars_for_var (vi->decl); sv; sv = sv->next)
|
for (sv = get_subvars_for_var (vi->decl); sv; sv = sv->next)
|
bitmap_set_bit (into, DECL_UID (sv->var));
|
bitmap_set_bit (into, DECL_UID (sv->var));
|
}
|
}
|
else if (TREE_CODE (vi->decl) == VAR_DECL
|
else if (TREE_CODE (vi->decl) == VAR_DECL
|
|| TREE_CODE (vi->decl) == PARM_DECL
|
|| TREE_CODE (vi->decl) == PARM_DECL
|
|| TREE_CODE (vi->decl) == RESULT_DECL)
|
|| TREE_CODE (vi->decl) == RESULT_DECL)
|
{
|
{
|
if (var_can_have_subvars (vi->decl)
|
if (var_can_have_subvars (vi->decl)
|
&& get_subvars_for_var (vi->decl))
|
&& get_subvars_for_var (vi->decl))
|
{
|
{
|
/* If VI->DECL is an aggregate for which we created
|
/* If VI->DECL is an aggregate for which we created
|
SFTs, add the SFT corresponding to VI->OFFSET. */
|
SFTs, add the SFT corresponding to VI->OFFSET. */
|
tree sft = get_subvar_at (vi->decl, vi->offset);
|
tree sft = get_subvar_at (vi->decl, vi->offset);
|
if (sft)
|
if (sft)
|
{
|
{
|
var_alias_set = get_alias_set (sft);
|
var_alias_set = get_alias_set (sft);
|
if (!vi->directly_dereferenced
|
if (!vi->directly_dereferenced
|
|| alias_sets_conflict_p (ptr_alias_set, var_alias_set))
|
|| alias_sets_conflict_p (ptr_alias_set, var_alias_set))
|
bitmap_set_bit (into, DECL_UID (sft));
|
bitmap_set_bit (into, DECL_UID (sft));
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Otherwise, just add VI->DECL to the alias set.
|
/* Otherwise, just add VI->DECL to the alias set.
|
Don't type prune artificial vars. */
|
Don't type prune artificial vars. */
|
if (vi->is_artificial_var)
|
if (vi->is_artificial_var)
|
bitmap_set_bit (into, DECL_UID (vi->decl));
|
bitmap_set_bit (into, DECL_UID (vi->decl));
|
else
|
else
|
{
|
{
|
var_alias_set = get_alias_set (vi->decl);
|
var_alias_set = get_alias_set (vi->decl);
|
if (!vi->directly_dereferenced
|
if (!vi->directly_dereferenced
|
|| alias_sets_conflict_p (ptr_alias_set, var_alias_set))
|
|| alias_sets_conflict_p (ptr_alias_set, var_alias_set))
|
bitmap_set_bit (into, DECL_UID (vi->decl));
|
bitmap_set_bit (into, DECL_UID (vi->decl));
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
|
|
static bool have_alias_info = false;
|
static bool have_alias_info = false;
|
|
|
/* Given a pointer variable P, fill in its points-to set, or return
|
/* Given a pointer variable P, fill in its points-to set, or return
|
false if we can't. */
|
false if we can't. */
|
|
|
bool
|
bool
|
find_what_p_points_to (tree p)
|
find_what_p_points_to (tree p)
|
{
|
{
|
tree lookup_p = p;
|
tree lookup_p = p;
|
varinfo_t vi;
|
varinfo_t vi;
|
|
|
if (!have_alias_info)
|
if (!have_alias_info)
|
return false;
|
return false;
|
|
|
/* For parameters, get at the points-to set for the actual parm
|
/* For parameters, get at the points-to set for the actual parm
|
decl. */
|
decl. */
|
if (TREE_CODE (p) == SSA_NAME
|
if (TREE_CODE (p) == SSA_NAME
|
&& TREE_CODE (SSA_NAME_VAR (p)) == PARM_DECL
|
&& TREE_CODE (SSA_NAME_VAR (p)) == PARM_DECL
|
&& default_def (SSA_NAME_VAR (p)) == p)
|
&& default_def (SSA_NAME_VAR (p)) == p)
|
lookup_p = SSA_NAME_VAR (p);
|
lookup_p = SSA_NAME_VAR (p);
|
|
|
vi = lookup_vi_for_tree (lookup_p);
|
vi = lookup_vi_for_tree (lookup_p);
|
if (vi)
|
if (vi)
|
{
|
{
|
|
|
if (vi->is_artificial_var)
|
if (vi->is_artificial_var)
|
return false;
|
return false;
|
|
|
/* See if this is a field or a structure. */
|
/* See if this is a field or a structure. */
|
if (vi->size != vi->fullsize)
|
if (vi->size != vi->fullsize)
|
{
|
{
|
/* Nothing currently asks about structure fields directly,
|
/* Nothing currently asks about structure fields directly,
|
but when they do, we need code here to hand back the
|
but when they do, we need code here to hand back the
|
points-to set. */
|
points-to set. */
|
if (!var_can_have_subvars (vi->decl)
|
if (!var_can_have_subvars (vi->decl)
|
|| get_subvars_for_var (vi->decl) == NULL)
|
|| get_subvars_for_var (vi->decl) == NULL)
|
return false;
|
return false;
|
}
|
}
|
else
|
else
|
{
|
{
|
struct ptr_info_def *pi = get_ptr_info (p);
|
struct ptr_info_def *pi = get_ptr_info (p);
|
unsigned int i;
|
unsigned int i;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
bitmap finished_solution;
|
bitmap finished_solution;
|
bitmap result;
|
bitmap result;
|
|
|
/* This variable may have been collapsed, let's get the real
|
/* This variable may have been collapsed, let's get the real
|
variable. */
|
variable. */
|
vi = get_varinfo (find (vi->id));
|
vi = get_varinfo (find (vi->id));
|
|
|
/* Translate artificial variables into SSA_NAME_PTR_INFO
|
/* Translate artificial variables into SSA_NAME_PTR_INFO
|
attributes. */
|
attributes. */
|
EXECUTE_IF_SET_IN_BITMAP (vi->solution, 0, i, bi)
|
EXECUTE_IF_SET_IN_BITMAP (vi->solution, 0, i, bi)
|
{
|
{
|
varinfo_t vi = get_varinfo (i);
|
varinfo_t vi = get_varinfo (i);
|
|
|
if (vi->is_artificial_var)
|
if (vi->is_artificial_var)
|
{
|
{
|
/* FIXME. READONLY should be handled better so that
|
/* FIXME. READONLY should be handled better so that
|
flow insensitive aliasing can disregard writable
|
flow insensitive aliasing can disregard writable
|
aliases. */
|
aliases. */
|
if (vi->id == nothing_id)
|
if (vi->id == nothing_id)
|
pi->pt_null = 1;
|
pi->pt_null = 1;
|
else if (vi->id == anything_id)
|
else if (vi->id == anything_id)
|
pi->pt_anything = 1;
|
pi->pt_anything = 1;
|
else if (vi->id == readonly_id)
|
else if (vi->id == readonly_id)
|
pi->pt_anything = 1;
|
pi->pt_anything = 1;
|
else if (vi->id == integer_id)
|
else if (vi->id == integer_id)
|
pi->pt_anything = 1;
|
pi->pt_anything = 1;
|
else if (vi->is_heap_var)
|
else if (vi->is_heap_var)
|
pi->pt_global_mem = 1;
|
pi->pt_global_mem = 1;
|
}
|
}
|
}
|
}
|
|
|
if (pi->pt_anything)
|
if (pi->pt_anything)
|
return false;
|
return false;
|
|
|
finished_solution = BITMAP_GGC_ALLOC ();
|
finished_solution = BITMAP_GGC_ALLOC ();
|
set_uids_in_ptset (vi->decl, finished_solution, vi->solution);
|
set_uids_in_ptset (vi->decl, finished_solution, vi->solution);
|
result = shared_bitmap_lookup (finished_solution);
|
result = shared_bitmap_lookup (finished_solution);
|
|
|
if (!result)
|
if (!result)
|
{
|
{
|
shared_bitmap_add (finished_solution);
|
shared_bitmap_add (finished_solution);
|
pi->pt_vars = finished_solution;
|
pi->pt_vars = finished_solution;
|
}
|
}
|
else
|
else
|
{
|
{
|
pi->pt_vars = result;
|
pi->pt_vars = result;
|
bitmap_clear (finished_solution);
|
bitmap_clear (finished_solution);
|
}
|
}
|
|
|
if (bitmap_empty_p (pi->pt_vars))
|
if (bitmap_empty_p (pi->pt_vars))
|
pi->pt_vars = NULL;
|
pi->pt_vars = NULL;
|
|
|
return true;
|
return true;
|
}
|
}
|
}
|
}
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
|
|
|
|
/* Dump points-to information to OUTFILE. */
|
/* Dump points-to information to OUTFILE. */
|
|
|
void
|
void
|
dump_sa_points_to_info (FILE *outfile)
|
dump_sa_points_to_info (FILE *outfile)
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
|
|
fprintf (outfile, "\nPoints-to sets\n\n");
|
fprintf (outfile, "\nPoints-to sets\n\n");
|
|
|
if (dump_flags & TDF_STATS)
|
if (dump_flags & TDF_STATS)
|
{
|
{
|
fprintf (outfile, "Stats:\n");
|
fprintf (outfile, "Stats:\n");
|
fprintf (outfile, "Total vars: %d\n", stats.total_vars);
|
fprintf (outfile, "Total vars: %d\n", stats.total_vars);
|
fprintf (outfile, "Non-pointer vars: %d\n",
|
fprintf (outfile, "Non-pointer vars: %d\n",
|
stats.nonpointer_vars);
|
stats.nonpointer_vars);
|
fprintf (outfile, "Statically unified vars: %d\n",
|
fprintf (outfile, "Statically unified vars: %d\n",
|
stats.unified_vars_static);
|
stats.unified_vars_static);
|
fprintf (outfile, "Dynamically unified vars: %d\n",
|
fprintf (outfile, "Dynamically unified vars: %d\n",
|
stats.unified_vars_dynamic);
|
stats.unified_vars_dynamic);
|
fprintf (outfile, "Iterations: %d\n", stats.iterations);
|
fprintf (outfile, "Iterations: %d\n", stats.iterations);
|
fprintf (outfile, "Number of edges: %d\n", stats.num_edges);
|
fprintf (outfile, "Number of edges: %d\n", stats.num_edges);
|
fprintf (outfile, "Number of implicit edges: %d\n",
|
fprintf (outfile, "Number of implicit edges: %d\n",
|
stats.num_implicit_edges);
|
stats.num_implicit_edges);
|
}
|
}
|
|
|
for (i = 0; i < VEC_length (varinfo_t, varmap); i++)
|
for (i = 0; i < VEC_length (varinfo_t, varmap); i++)
|
dump_solution_for_var (outfile, i);
|
dump_solution_for_var (outfile, i);
|
}
|
}
|
|
|
|
|
/* Debug points-to information to stderr. */
|
/* Debug points-to information to stderr. */
|
|
|
void
|
void
|
debug_sa_points_to_info (void)
|
debug_sa_points_to_info (void)
|
{
|
{
|
dump_sa_points_to_info (stderr);
|
dump_sa_points_to_info (stderr);
|
}
|
}
|
|
|
|
|
/* Initialize the always-existing constraint variables for NULL
|
/* Initialize the always-existing constraint variables for NULL
|
ANYTHING, READONLY, and INTEGER */
|
ANYTHING, READONLY, and INTEGER */
|
|
|
static void
|
static void
|
init_base_vars (void)
|
init_base_vars (void)
|
{
|
{
|
struct constraint_expr lhs, rhs;
|
struct constraint_expr lhs, rhs;
|
|
|
/* Create the NULL variable, used to represent that a variable points
|
/* Create the NULL variable, used to represent that a variable points
|
to NULL. */
|
to NULL. */
|
nothing_tree = create_tmp_var_raw (void_type_node, "NULL");
|
nothing_tree = create_tmp_var_raw (void_type_node, "NULL");
|
var_nothing = new_var_info (nothing_tree, 0, "NULL");
|
var_nothing = new_var_info (nothing_tree, 0, "NULL");
|
insert_vi_for_tree (nothing_tree, var_nothing);
|
insert_vi_for_tree (nothing_tree, var_nothing);
|
var_nothing->is_artificial_var = 1;
|
var_nothing->is_artificial_var = 1;
|
var_nothing->offset = 0;
|
var_nothing->offset = 0;
|
var_nothing->size = ~0;
|
var_nothing->size = ~0;
|
var_nothing->fullsize = ~0;
|
var_nothing->fullsize = ~0;
|
var_nothing->is_special_var = 1;
|
var_nothing->is_special_var = 1;
|
nothing_id = 0;
|
nothing_id = 0;
|
VEC_safe_push (varinfo_t, heap, varmap, var_nothing);
|
VEC_safe_push (varinfo_t, heap, varmap, var_nothing);
|
|
|
/* Create the ANYTHING variable, used to represent that a variable
|
/* Create the ANYTHING variable, used to represent that a variable
|
points to some unknown piece of memory. */
|
points to some unknown piece of memory. */
|
anything_tree = create_tmp_var_raw (void_type_node, "ANYTHING");
|
anything_tree = create_tmp_var_raw (void_type_node, "ANYTHING");
|
var_anything = new_var_info (anything_tree, 1, "ANYTHING");
|
var_anything = new_var_info (anything_tree, 1, "ANYTHING");
|
insert_vi_for_tree (anything_tree, var_anything);
|
insert_vi_for_tree (anything_tree, var_anything);
|
var_anything->is_artificial_var = 1;
|
var_anything->is_artificial_var = 1;
|
var_anything->size = ~0;
|
var_anything->size = ~0;
|
var_anything->offset = 0;
|
var_anything->offset = 0;
|
var_anything->next = NULL;
|
var_anything->next = NULL;
|
var_anything->fullsize = ~0;
|
var_anything->fullsize = ~0;
|
var_anything->is_special_var = 1;
|
var_anything->is_special_var = 1;
|
anything_id = 1;
|
anything_id = 1;
|
|
|
/* Anything points to anything. This makes deref constraints just
|
/* Anything points to anything. This makes deref constraints just
|
work in the presence of linked list and other p = *p type loops,
|
work in the presence of linked list and other p = *p type loops,
|
by saying that *ANYTHING = ANYTHING. */
|
by saying that *ANYTHING = ANYTHING. */
|
VEC_safe_push (varinfo_t, heap, varmap, var_anything);
|
VEC_safe_push (varinfo_t, heap, varmap, var_anything);
|
lhs.type = SCALAR;
|
lhs.type = SCALAR;
|
lhs.var = anything_id;
|
lhs.var = anything_id;
|
lhs.offset = 0;
|
lhs.offset = 0;
|
rhs.type = ADDRESSOF;
|
rhs.type = ADDRESSOF;
|
rhs.var = anything_id;
|
rhs.var = anything_id;
|
rhs.offset = 0;
|
rhs.offset = 0;
|
|
|
/* This specifically does not use process_constraint because
|
/* This specifically does not use process_constraint because
|
process_constraint ignores all anything = anything constraints, since all
|
process_constraint ignores all anything = anything constraints, since all
|
but this one are redundant. */
|
but this one are redundant. */
|
VEC_safe_push (constraint_t, heap, constraints, new_constraint (lhs, rhs));
|
VEC_safe_push (constraint_t, heap, constraints, new_constraint (lhs, rhs));
|
|
|
/* Create the READONLY variable, used to represent that a variable
|
/* Create the READONLY variable, used to represent that a variable
|
points to readonly memory. */
|
points to readonly memory. */
|
readonly_tree = create_tmp_var_raw (void_type_node, "READONLY");
|
readonly_tree = create_tmp_var_raw (void_type_node, "READONLY");
|
var_readonly = new_var_info (readonly_tree, 2, "READONLY");
|
var_readonly = new_var_info (readonly_tree, 2, "READONLY");
|
var_readonly->is_artificial_var = 1;
|
var_readonly->is_artificial_var = 1;
|
var_readonly->offset = 0;
|
var_readonly->offset = 0;
|
var_readonly->size = ~0;
|
var_readonly->size = ~0;
|
var_readonly->fullsize = ~0;
|
var_readonly->fullsize = ~0;
|
var_readonly->next = NULL;
|
var_readonly->next = NULL;
|
var_readonly->is_special_var = 1;
|
var_readonly->is_special_var = 1;
|
insert_vi_for_tree (readonly_tree, var_readonly);
|
insert_vi_for_tree (readonly_tree, var_readonly);
|
readonly_id = 2;
|
readonly_id = 2;
|
VEC_safe_push (varinfo_t, heap, varmap, var_readonly);
|
VEC_safe_push (varinfo_t, heap, varmap, var_readonly);
|
|
|
/* readonly memory points to anything, in order to make deref
|
/* readonly memory points to anything, in order to make deref
|
easier. In reality, it points to anything the particular
|
easier. In reality, it points to anything the particular
|
readonly variable can point to, but we don't track this
|
readonly variable can point to, but we don't track this
|
separately. */
|
separately. */
|
lhs.type = SCALAR;
|
lhs.type = SCALAR;
|
lhs.var = readonly_id;
|
lhs.var = readonly_id;
|
lhs.offset = 0;
|
lhs.offset = 0;
|
rhs.type = ADDRESSOF;
|
rhs.type = ADDRESSOF;
|
rhs.var = anything_id;
|
rhs.var = anything_id;
|
rhs.offset = 0;
|
rhs.offset = 0;
|
|
|
process_constraint (new_constraint (lhs, rhs));
|
process_constraint (new_constraint (lhs, rhs));
|
|
|
/* Create the INTEGER variable, used to represent that a variable points
|
/* Create the INTEGER variable, used to represent that a variable points
|
to an INTEGER. */
|
to an INTEGER. */
|
integer_tree = create_tmp_var_raw (void_type_node, "INTEGER");
|
integer_tree = create_tmp_var_raw (void_type_node, "INTEGER");
|
var_integer = new_var_info (integer_tree, 3, "INTEGER");
|
var_integer = new_var_info (integer_tree, 3, "INTEGER");
|
insert_vi_for_tree (integer_tree, var_integer);
|
insert_vi_for_tree (integer_tree, var_integer);
|
var_integer->is_artificial_var = 1;
|
var_integer->is_artificial_var = 1;
|
var_integer->size = ~0;
|
var_integer->size = ~0;
|
var_integer->fullsize = ~0;
|
var_integer->fullsize = ~0;
|
var_integer->offset = 0;
|
var_integer->offset = 0;
|
var_integer->next = NULL;
|
var_integer->next = NULL;
|
var_integer->is_special_var = 1;
|
var_integer->is_special_var = 1;
|
integer_id = 3;
|
integer_id = 3;
|
VEC_safe_push (varinfo_t, heap, varmap, var_integer);
|
VEC_safe_push (varinfo_t, heap, varmap, var_integer);
|
|
|
/* INTEGER = ANYTHING, because we don't know where a dereference of
|
/* INTEGER = ANYTHING, because we don't know where a dereference of
|
a random integer will point to. */
|
a random integer will point to. */
|
lhs.type = SCALAR;
|
lhs.type = SCALAR;
|
lhs.var = integer_id;
|
lhs.var = integer_id;
|
lhs.offset = 0;
|
lhs.offset = 0;
|
rhs.type = ADDRESSOF;
|
rhs.type = ADDRESSOF;
|
rhs.var = anything_id;
|
rhs.var = anything_id;
|
rhs.offset = 0;
|
rhs.offset = 0;
|
process_constraint (new_constraint (lhs, rhs));
|
process_constraint (new_constraint (lhs, rhs));
|
|
|
/* Create the ESCAPED_VARS variable used to represent variables that
|
/* Create the ESCAPED_VARS variable used to represent variables that
|
escape this function. */
|
escape this function. */
|
escaped_vars_tree = create_tmp_var_raw (void_type_node, "ESCAPED_VARS");
|
escaped_vars_tree = create_tmp_var_raw (void_type_node, "ESCAPED_VARS");
|
var_escaped_vars = new_var_info (escaped_vars_tree, 4, "ESCAPED_VARS");
|
var_escaped_vars = new_var_info (escaped_vars_tree, 4, "ESCAPED_VARS");
|
insert_vi_for_tree (escaped_vars_tree, var_escaped_vars);
|
insert_vi_for_tree (escaped_vars_tree, var_escaped_vars);
|
var_escaped_vars->is_artificial_var = 1;
|
var_escaped_vars->is_artificial_var = 1;
|
var_escaped_vars->size = ~0;
|
var_escaped_vars->size = ~0;
|
var_escaped_vars->fullsize = ~0;
|
var_escaped_vars->fullsize = ~0;
|
var_escaped_vars->offset = 0;
|
var_escaped_vars->offset = 0;
|
var_escaped_vars->next = NULL;
|
var_escaped_vars->next = NULL;
|
escaped_vars_id = 4;
|
escaped_vars_id = 4;
|
VEC_safe_push (varinfo_t, heap, varmap, var_escaped_vars);
|
VEC_safe_push (varinfo_t, heap, varmap, var_escaped_vars);
|
|
|
/* ESCAPED_VARS = *ESCAPED_VARS */
|
/* ESCAPED_VARS = *ESCAPED_VARS */
|
lhs.type = SCALAR;
|
lhs.type = SCALAR;
|
lhs.var = escaped_vars_id;
|
lhs.var = escaped_vars_id;
|
lhs.offset = 0;
|
lhs.offset = 0;
|
rhs.type = DEREF;
|
rhs.type = DEREF;
|
rhs.var = escaped_vars_id;
|
rhs.var = escaped_vars_id;
|
rhs.offset = 0;
|
rhs.offset = 0;
|
process_constraint (new_constraint (lhs, rhs));
|
process_constraint (new_constraint (lhs, rhs));
|
|
|
}
|
}
|
|
|
/* Initialize things necessary to perform PTA */
|
/* Initialize things necessary to perform PTA */
|
|
|
static void
|
static void
|
init_alias_vars (void)
|
init_alias_vars (void)
|
{
|
{
|
bitmap_obstack_initialize (&pta_obstack);
|
bitmap_obstack_initialize (&pta_obstack);
|
bitmap_obstack_initialize (&oldpta_obstack);
|
bitmap_obstack_initialize (&oldpta_obstack);
|
bitmap_obstack_initialize (&predbitmap_obstack);
|
bitmap_obstack_initialize (&predbitmap_obstack);
|
|
|
constraint_pool = create_alloc_pool ("Constraint pool",
|
constraint_pool = create_alloc_pool ("Constraint pool",
|
sizeof (struct constraint), 30);
|
sizeof (struct constraint), 30);
|
variable_info_pool = create_alloc_pool ("Variable info pool",
|
variable_info_pool = create_alloc_pool ("Variable info pool",
|
sizeof (struct variable_info), 30);
|
sizeof (struct variable_info), 30);
|
constraints = VEC_alloc (constraint_t, heap, 8);
|
constraints = VEC_alloc (constraint_t, heap, 8);
|
varmap = VEC_alloc (varinfo_t, heap, 8);
|
varmap = VEC_alloc (varinfo_t, heap, 8);
|
vi_for_tree = pointer_map_create ();
|
vi_for_tree = pointer_map_create ();
|
|
|
memset (&stats, 0, sizeof (stats));
|
memset (&stats, 0, sizeof (stats));
|
shared_bitmap_table = htab_create (511, shared_bitmap_hash,
|
shared_bitmap_table = htab_create (511, shared_bitmap_hash,
|
shared_bitmap_eq, free);
|
shared_bitmap_eq, free);
|
init_base_vars ();
|
init_base_vars ();
|
}
|
}
|
|
|
/* Given a statement STMT, generate necessary constraints to
|
/* Given a statement STMT, generate necessary constraints to
|
escaped_vars for the escaping variables. */
|
escaped_vars for the escaping variables. */
|
|
|
static void
|
static void
|
find_escape_constraints (tree stmt)
|
find_escape_constraints (tree stmt)
|
{
|
{
|
enum escape_type stmt_escape_type = is_escape_site (stmt);
|
enum escape_type stmt_escape_type = is_escape_site (stmt);
|
tree rhs;
|
tree rhs;
|
VEC(ce_s, heap) *rhsc = NULL;
|
VEC(ce_s, heap) *rhsc = NULL;
|
struct constraint_expr *c;
|
struct constraint_expr *c;
|
size_t i;
|
size_t i;
|
|
|
if (stmt_escape_type == NO_ESCAPE)
|
if (stmt_escape_type == NO_ESCAPE)
|
return;
|
return;
|
|
|
if (TREE_CODE (stmt) == RETURN_EXPR)
|
if (TREE_CODE (stmt) == RETURN_EXPR)
|
{
|
{
|
/* Returns are either bare, with an embedded MODIFY_EXPR, or
|
/* Returns are either bare, with an embedded MODIFY_EXPR, or
|
just a plain old expression. */
|
just a plain old expression. */
|
if (!TREE_OPERAND (stmt, 0))
|
if (!TREE_OPERAND (stmt, 0))
|
return;
|
return;
|
if (TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR)
|
if (TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR)
|
rhs = TREE_OPERAND (TREE_OPERAND (stmt, 0), 1);
|
rhs = TREE_OPERAND (TREE_OPERAND (stmt, 0), 1);
|
else
|
else
|
rhs = TREE_OPERAND (stmt, 0);
|
rhs = TREE_OPERAND (stmt, 0);
|
|
|
get_constraint_for (rhs, &rhsc);
|
get_constraint_for (rhs, &rhsc);
|
for (i = 0; VEC_iterate (ce_s, rhsc, i, c); i++)
|
for (i = 0; VEC_iterate (ce_s, rhsc, i, c); i++)
|
make_constraint_to_escaped (*c);
|
make_constraint_to_escaped (*c);
|
VEC_free (ce_s, heap, rhsc);
|
VEC_free (ce_s, heap, rhsc);
|
return;
|
return;
|
}
|
}
|
else if (TREE_CODE (stmt) == ASM_EXPR)
|
else if (TREE_CODE (stmt) == ASM_EXPR)
|
{
|
{
|
/* Whatever the inputs of the ASM are, escape. */
|
/* Whatever the inputs of the ASM are, escape. */
|
tree arg;
|
tree arg;
|
|
|
for (arg = ASM_INPUTS (stmt); arg; arg = TREE_CHAIN (arg))
|
for (arg = ASM_INPUTS (stmt); arg; arg = TREE_CHAIN (arg))
|
{
|
{
|
rhsc = NULL;
|
rhsc = NULL;
|
get_constraint_for (TREE_VALUE (arg), &rhsc);
|
get_constraint_for (TREE_VALUE (arg), &rhsc);
|
for (i = 0; VEC_iterate (ce_s, rhsc, i, c); i++)
|
for (i = 0; VEC_iterate (ce_s, rhsc, i, c); i++)
|
make_constraint_to_escaped (*c);
|
make_constraint_to_escaped (*c);
|
VEC_free (ce_s, heap, rhsc);
|
VEC_free (ce_s, heap, rhsc);
|
}
|
}
|
return;
|
return;
|
}
|
}
|
else if (TREE_CODE (stmt) == CALL_EXPR
|
else if (TREE_CODE (stmt) == CALL_EXPR
|
|| (TREE_CODE (stmt) == MODIFY_EXPR
|
|| (TREE_CODE (stmt) == MODIFY_EXPR
|
&& TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR))
|
&& TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR))
|
{
|
{
|
/* Calls cause all of the arguments passed in to escape. */
|
/* Calls cause all of the arguments passed in to escape. */
|
tree arg;
|
tree arg;
|
|
|
if (TREE_CODE (stmt) == MODIFY_EXPR)
|
if (TREE_CODE (stmt) == MODIFY_EXPR)
|
stmt = TREE_OPERAND (stmt, 1);
|
stmt = TREE_OPERAND (stmt, 1);
|
for (arg = TREE_OPERAND (stmt, 1); arg; arg = TREE_CHAIN (arg))
|
for (arg = TREE_OPERAND (stmt, 1); arg; arg = TREE_CHAIN (arg))
|
{
|
{
|
if (POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arg))))
|
if (POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arg))))
|
{
|
{
|
rhsc = NULL;
|
rhsc = NULL;
|
get_constraint_for (TREE_VALUE (arg), &rhsc);
|
get_constraint_for (TREE_VALUE (arg), &rhsc);
|
for (i = 0; VEC_iterate (ce_s, rhsc, i, c); i++)
|
for (i = 0; VEC_iterate (ce_s, rhsc, i, c); i++)
|
make_constraint_to_escaped (*c);
|
make_constraint_to_escaped (*c);
|
VEC_free (ce_s, heap, rhsc);
|
VEC_free (ce_s, heap, rhsc);
|
}
|
}
|
}
|
}
|
return;
|
return;
|
}
|
}
|
else
|
else
|
{
|
{
|
gcc_assert (TREE_CODE (stmt) == MODIFY_EXPR);
|
gcc_assert (TREE_CODE (stmt) == MODIFY_EXPR);
|
}
|
}
|
|
|
gcc_assert (stmt_escape_type == ESCAPE_BAD_CAST
|
gcc_assert (stmt_escape_type == ESCAPE_BAD_CAST
|
|| stmt_escape_type == ESCAPE_STORED_IN_GLOBAL
|
|| stmt_escape_type == ESCAPE_STORED_IN_GLOBAL
|
|| stmt_escape_type == ESCAPE_UNKNOWN);
|
|| stmt_escape_type == ESCAPE_UNKNOWN);
|
rhs = TREE_OPERAND (stmt, 1);
|
rhs = TREE_OPERAND (stmt, 1);
|
|
|
/* Look through casts for the real escaping variable.
|
/* Look through casts for the real escaping variable.
|
Constants don't really escape, so ignore them.
|
Constants don't really escape, so ignore them.
|
Otherwise, whatever escapes must be on our RHS. */
|
Otherwise, whatever escapes must be on our RHS. */
|
if (TREE_CODE (rhs) == NOP_EXPR
|
if (TREE_CODE (rhs) == NOP_EXPR
|
|| TREE_CODE (rhs) == CONVERT_EXPR
|
|| TREE_CODE (rhs) == CONVERT_EXPR
|
|| TREE_CODE (rhs) == NON_LVALUE_EXPR)
|
|| TREE_CODE (rhs) == NON_LVALUE_EXPR)
|
{
|
{
|
get_constraint_for (TREE_OPERAND (rhs, 0), &rhsc);
|
get_constraint_for (TREE_OPERAND (rhs, 0), &rhsc);
|
}
|
}
|
else if (CONSTANT_CLASS_P (rhs))
|
else if (CONSTANT_CLASS_P (rhs))
|
return;
|
return;
|
else
|
else
|
{
|
{
|
get_constraint_for (rhs, &rhsc);
|
get_constraint_for (rhs, &rhsc);
|
}
|
}
|
for (i = 0; VEC_iterate (ce_s, rhsc, i, c); i++)
|
for (i = 0; VEC_iterate (ce_s, rhsc, i, c); i++)
|
make_constraint_to_escaped (*c);
|
make_constraint_to_escaped (*c);
|
VEC_free (ce_s, heap, rhsc);
|
VEC_free (ce_s, heap, rhsc);
|
}
|
}
|
|
|
|
|
/* Remove the REF and ADDRESS edges from GRAPH, as well as all the
|
/* Remove the REF and ADDRESS edges from GRAPH, as well as all the
|
predecessor edges. */
|
predecessor edges. */
|
|
|
static void
|
static void
|
remove_preds_and_fake_succs (constraint_graph_t graph)
|
remove_preds_and_fake_succs (constraint_graph_t graph)
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
|
|
/* Clear the implicit ref and address nodes from the successor
|
/* Clear the implicit ref and address nodes from the successor
|
lists. */
|
lists. */
|
for (i = 0; i < FIRST_REF_NODE; i++)
|
for (i = 0; i < FIRST_REF_NODE; i++)
|
{
|
{
|
if (graph->succs[i])
|
if (graph->succs[i])
|
bitmap_clear_range (graph->succs[i], FIRST_REF_NODE,
|
bitmap_clear_range (graph->succs[i], FIRST_REF_NODE,
|
FIRST_REF_NODE * 2);
|
FIRST_REF_NODE * 2);
|
}
|
}
|
|
|
/* Free the successor list for the non-ref nodes. */
|
/* Free the successor list for the non-ref nodes. */
|
for (i = FIRST_REF_NODE; i < graph->size; i++)
|
for (i = FIRST_REF_NODE; i < graph->size; i++)
|
{
|
{
|
if (graph->succs[i])
|
if (graph->succs[i])
|
BITMAP_FREE (graph->succs[i]);
|
BITMAP_FREE (graph->succs[i]);
|
}
|
}
|
|
|
/* Now reallocate the size of the successor list as, and blow away
|
/* Now reallocate the size of the successor list as, and blow away
|
the predecessor bitmaps. */
|
the predecessor bitmaps. */
|
graph->size = VEC_length (varinfo_t, varmap);
|
graph->size = VEC_length (varinfo_t, varmap);
|
graph->succs = xrealloc (graph->succs, graph->size * sizeof (bitmap));
|
graph->succs = xrealloc (graph->succs, graph->size * sizeof (bitmap));
|
|
|
free (graph->implicit_preds);
|
free (graph->implicit_preds);
|
graph->implicit_preds = NULL;
|
graph->implicit_preds = NULL;
|
free (graph->preds);
|
free (graph->preds);
|
graph->preds = NULL;
|
graph->preds = NULL;
|
bitmap_obstack_release (&predbitmap_obstack);
|
bitmap_obstack_release (&predbitmap_obstack);
|
}
|
}
|
|
|
/* Create points-to sets for the current function. See the comments
|
/* Create points-to sets for the current function. See the comments
|
at the start of the file for an algorithmic overview. */
|
at the start of the file for an algorithmic overview. */
|
|
|
void
|
void
|
compute_points_to_sets (struct alias_info *ai)
|
compute_points_to_sets (struct alias_info *ai)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
struct scc_info *si;
|
struct scc_info *si;
|
|
|
timevar_push (TV_TREE_PTA);
|
timevar_push (TV_TREE_PTA);
|
|
|
init_alias_vars ();
|
init_alias_vars ();
|
init_alias_heapvars ();
|
init_alias_heapvars ();
|
|
|
intra_create_variable_infos ();
|
intra_create_variable_infos ();
|
|
|
/* Now walk all statements and derive aliases. */
|
/* Now walk all statements and derive aliases. */
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
block_stmt_iterator bsi;
|
block_stmt_iterator bsi;
|
tree phi;
|
tree phi;
|
|
|
for (phi = phi_nodes (bb); phi; phi = TREE_CHAIN (phi))
|
for (phi = phi_nodes (bb); phi; phi = TREE_CHAIN (phi))
|
{
|
{
|
if (is_gimple_reg (PHI_RESULT (phi)))
|
if (is_gimple_reg (PHI_RESULT (phi)))
|
{
|
{
|
find_func_aliases (phi);
|
find_func_aliases (phi);
|
/* Update various related attributes like escaped
|
/* Update various related attributes like escaped
|
addresses, pointer dereferences for loads and stores.
|
addresses, pointer dereferences for loads and stores.
|
This is used when creating name tags and alias
|
This is used when creating name tags and alias
|
sets. */
|
sets. */
|
update_alias_info (phi, ai);
|
update_alias_info (phi, ai);
|
}
|
}
|
}
|
}
|
|
|
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
|
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
|
{
|
{
|
tree stmt = bsi_stmt (bsi);
|
tree stmt = bsi_stmt (bsi);
|
|
|
find_func_aliases (stmt);
|
find_func_aliases (stmt);
|
find_escape_constraints (stmt);
|
find_escape_constraints (stmt);
|
/* Update various related attributes like escaped
|
/* Update various related attributes like escaped
|
addresses, pointer dereferences for loads and stores.
|
addresses, pointer dereferences for loads and stores.
|
This is used when creating name tags and alias
|
This is used when creating name tags and alias
|
sets. */
|
sets. */
|
update_alias_info (stmt, ai);
|
update_alias_info (stmt, ai);
|
}
|
}
|
}
|
}
|
|
|
|
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file, "Points-to analysis\n\nConstraints:\n\n");
|
fprintf (dump_file, "Points-to analysis\n\nConstraints:\n\n");
|
dump_constraints (dump_file);
|
dump_constraints (dump_file);
|
}
|
}
|
|
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file,
|
fprintf (dump_file,
|
"\nCollapsing static cycles and doing variable "
|
"\nCollapsing static cycles and doing variable "
|
"substitution:\n");
|
"substitution:\n");
|
|
|
build_pred_graph ();
|
build_pred_graph ();
|
si = perform_var_substitution (graph);
|
si = perform_var_substitution (graph);
|
move_complex_constraints (graph, si);
|
move_complex_constraints (graph, si);
|
free_var_substitution_info (si);
|
free_var_substitution_info (si);
|
|
|
build_succ_graph ();
|
build_succ_graph ();
|
find_indirect_cycles (graph);
|
find_indirect_cycles (graph);
|
|
|
/* Implicit nodes and predecessors are no longer necessary at this
|
/* Implicit nodes and predecessors are no longer necessary at this
|
point. */
|
point. */
|
remove_preds_and_fake_succs (graph);
|
remove_preds_and_fake_succs (graph);
|
|
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file, "\nSolving graph:\n");
|
fprintf (dump_file, "\nSolving graph:\n");
|
|
|
solve_graph (graph);
|
solve_graph (graph);
|
|
|
if (dump_file)
|
if (dump_file)
|
dump_sa_points_to_info (dump_file);
|
dump_sa_points_to_info (dump_file);
|
have_alias_info = true;
|
have_alias_info = true;
|
|
|
timevar_pop (TV_TREE_PTA);
|
timevar_pop (TV_TREE_PTA);
|
}
|
}
|
|
|
/* Delete created points-to sets. */
|
/* Delete created points-to sets. */
|
|
|
void
|
void
|
delete_points_to_sets (void)
|
delete_points_to_sets (void)
|
{
|
{
|
varinfo_t v;
|
varinfo_t v;
|
int i;
|
int i;
|
|
|
htab_delete (shared_bitmap_table);
|
htab_delete (shared_bitmap_table);
|
if (dump_file && (dump_flags & TDF_STATS))
|
if (dump_file && (dump_flags & TDF_STATS))
|
fprintf (dump_file, "Points to sets created:%d\n",
|
fprintf (dump_file, "Points to sets created:%d\n",
|
stats.points_to_sets_created);
|
stats.points_to_sets_created);
|
|
|
pointer_map_destroy (vi_for_tree);
|
pointer_map_destroy (vi_for_tree);
|
bitmap_obstack_release (&pta_obstack);
|
bitmap_obstack_release (&pta_obstack);
|
VEC_free (constraint_t, heap, constraints);
|
VEC_free (constraint_t, heap, constraints);
|
|
|
for (i = 0; VEC_iterate (varinfo_t, varmap, i, v); i++)
|
for (i = 0; VEC_iterate (varinfo_t, varmap, i, v); i++)
|
VEC_free (constraint_t, heap, graph->complex[i]);
|
VEC_free (constraint_t, heap, graph->complex[i]);
|
free (graph->complex);
|
free (graph->complex);
|
|
|
free (graph->rep);
|
free (graph->rep);
|
free (graph->succs);
|
free (graph->succs);
|
free (graph->indirect_cycles);
|
free (graph->indirect_cycles);
|
free (graph);
|
free (graph);
|
|
|
VEC_free (varinfo_t, heap, varmap);
|
VEC_free (varinfo_t, heap, varmap);
|
free_alloc_pool (variable_info_pool);
|
free_alloc_pool (variable_info_pool);
|
free_alloc_pool (constraint_pool);
|
free_alloc_pool (constraint_pool);
|
have_alias_info = false;
|
have_alias_info = false;
|
}
|
}
|
|
|
/* Return true if we should execute IPA PTA. */
|
/* Return true if we should execute IPA PTA. */
|
static bool
|
static bool
|
gate_ipa_pta (void)
|
gate_ipa_pta (void)
|
{
|
{
|
return (flag_unit_at_a_time != 0
|
return (flag_unit_at_a_time != 0
|
&& flag_ipa_pta
|
&& flag_ipa_pta
|
/* Don't bother doing anything if the program has errors. */
|
/* Don't bother doing anything if the program has errors. */
|
&& !(errorcount || sorrycount));
|
&& !(errorcount || sorrycount));
|
}
|
}
|
|
|
/* Execute the driver for IPA PTA. */
|
/* Execute the driver for IPA PTA. */
|
static unsigned int
|
static unsigned int
|
ipa_pta_execute (void)
|
ipa_pta_execute (void)
|
{
|
{
|
#if 0
|
#if 0
|
struct cgraph_node *node;
|
struct cgraph_node *node;
|
in_ipa_mode = 1;
|
in_ipa_mode = 1;
|
init_alias_heapvars ();
|
init_alias_heapvars ();
|
init_alias_vars ();
|
init_alias_vars ();
|
|
|
for (node = cgraph_nodes; node; node = node->next)
|
for (node = cgraph_nodes; node; node = node->next)
|
{
|
{
|
if (!node->analyzed || cgraph_is_master_clone (node))
|
if (!node->analyzed || cgraph_is_master_clone (node))
|
{
|
{
|
unsigned int varid;
|
unsigned int varid;
|
|
|
varid = create_function_info_for (node->decl,
|
varid = create_function_info_for (node->decl,
|
cgraph_node_name (node));
|
cgraph_node_name (node));
|
if (node->local.externally_visible)
|
if (node->local.externally_visible)
|
{
|
{
|
varinfo_t fi = get_varinfo (varid);
|
varinfo_t fi = get_varinfo (varid);
|
for (; fi; fi = fi->next)
|
for (; fi; fi = fi->next)
|
make_constraint_from_escaped (fi);
|
make_constraint_from_escaped (fi);
|
}
|
}
|
}
|
}
|
}
|
}
|
for (node = cgraph_nodes; node; node = node->next)
|
for (node = cgraph_nodes; node; node = node->next)
|
{
|
{
|
if (node->analyzed && cgraph_is_master_clone (node))
|
if (node->analyzed && cgraph_is_master_clone (node))
|
{
|
{
|
struct function *cfun = DECL_STRUCT_FUNCTION (node->decl);
|
struct function *cfun = DECL_STRUCT_FUNCTION (node->decl);
|
basic_block bb;
|
basic_block bb;
|
tree old_func_decl = current_function_decl;
|
tree old_func_decl = current_function_decl;
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file,
|
fprintf (dump_file,
|
"Generating constraints for %s\n",
|
"Generating constraints for %s\n",
|
cgraph_node_name (node));
|
cgraph_node_name (node));
|
push_cfun (cfun);
|
push_cfun (cfun);
|
current_function_decl = node->decl;
|
current_function_decl = node->decl;
|
|
|
FOR_EACH_BB_FN (bb, cfun)
|
FOR_EACH_BB_FN (bb, cfun)
|
{
|
{
|
block_stmt_iterator bsi;
|
block_stmt_iterator bsi;
|
tree phi;
|
tree phi;
|
|
|
for (phi = phi_nodes (bb); phi; phi = TREE_CHAIN (phi))
|
for (phi = phi_nodes (bb); phi; phi = TREE_CHAIN (phi))
|
{
|
{
|
if (is_gimple_reg (PHI_RESULT (phi)))
|
if (is_gimple_reg (PHI_RESULT (phi)))
|
{
|
{
|
find_func_aliases (phi);
|
find_func_aliases (phi);
|
}
|
}
|
}
|
}
|
|
|
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
|
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
|
{
|
{
|
tree stmt = bsi_stmt (bsi);
|
tree stmt = bsi_stmt (bsi);
|
find_func_aliases (stmt);
|
find_func_aliases (stmt);
|
}
|
}
|
}
|
}
|
current_function_decl = old_func_decl;
|
current_function_decl = old_func_decl;
|
pop_cfun ();
|
pop_cfun ();
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Make point to anything. */
|
/* Make point to anything. */
|
}
|
}
|
}
|
}
|
|
|
build_constraint_graph ();
|
build_constraint_graph ();
|
|
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file, "Points-to analysis\n\nConstraints:\n\n");
|
fprintf (dump_file, "Points-to analysis\n\nConstraints:\n\n");
|
dump_constraints (dump_file);
|
dump_constraints (dump_file);
|
}
|
}
|
|
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file,
|
fprintf (dump_file,
|
"\nCollapsing static cycles and doing variable "
|
"\nCollapsing static cycles and doing variable "
|
"substitution:\n");
|
"substitution:\n");
|
|
|
find_and_collapse_graph_cycles (graph, false);
|
find_and_collapse_graph_cycles (graph, false);
|
perform_var_substitution (graph);
|
perform_var_substitution (graph);
|
|
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file, "\nSolving graph:\n");
|
fprintf (dump_file, "\nSolving graph:\n");
|
|
|
solve_graph (graph);
|
solve_graph (graph);
|
|
|
if (dump_file)
|
if (dump_file)
|
dump_sa_points_to_info (dump_file);
|
dump_sa_points_to_info (dump_file);
|
in_ipa_mode = 0;
|
in_ipa_mode = 0;
|
delete_alias_heapvars ();
|
delete_alias_heapvars ();
|
delete_points_to_sets ();
|
delete_points_to_sets ();
|
#endif
|
#endif
|
return 0;
|
return 0;
|
}
|
}
|
|
|
struct tree_opt_pass pass_ipa_pta =
|
struct tree_opt_pass pass_ipa_pta =
|
{
|
{
|
"pta", /* name */
|
"pta", /* name */
|
gate_ipa_pta, /* gate */
|
gate_ipa_pta, /* gate */
|
ipa_pta_execute, /* execute */
|
ipa_pta_execute, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_IPA_PTA, /* tv_id */
|
TV_IPA_PTA, /* tv_id */
|
0, /* properties_required */
|
0, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
0, /* todo_flags_finish */
|
0, /* todo_flags_finish */
|
0 /* letter */
|
0 /* letter */
|
};
|
};
|
|
|
/* Initialize the heapvar for statement mapping. */
|
/* Initialize the heapvar for statement mapping. */
|
void
|
void
|
init_alias_heapvars (void)
|
init_alias_heapvars (void)
|
{
|
{
|
if (!heapvar_for_stmt)
|
if (!heapvar_for_stmt)
|
heapvar_for_stmt = htab_create_ggc (11, tree_map_hash, tree_map_eq,
|
heapvar_for_stmt = htab_create_ggc (11, tree_map_hash, tree_map_eq,
|
NULL);
|
NULL);
|
nonlocal_all = NULL_TREE;
|
nonlocal_all = NULL_TREE;
|
}
|
}
|
|
|
void
|
void
|
delete_alias_heapvars (void)
|
delete_alias_heapvars (void)
|
{
|
{
|
nonlocal_all = NULL_TREE;
|
nonlocal_all = NULL_TREE;
|
htab_delete (heapvar_for_stmt);
|
htab_delete (heapvar_for_stmt);
|
heapvar_for_stmt = NULL;
|
heapvar_for_stmt = NULL;
|
}
|
}
|
|
|
#include "gt-tree-ssa-structalias.h"
|
#include "gt-tree-ssa-structalias.h"
|
|
|
