static void
fini_copy_prop (void)
{
unsigned i;
/* Set the final copy-of value for each variable by traversing the
copy-of chains. */
for (i = 1; i < num_ssa_names; i++)
{
tree var = ssa_name (i);
if (!var
|| !copy_of[i].value
|| copy_of[i].value == var)
continue;
/* In theory the points-to solution of all members of the
copy chain is their intersection. For now we do not bother
to compute this but only make sure we do not lose points-to
information completely by setting the points-to solution
of the representative to the first solution we find if
it doesn't have one already. */
if (copy_of[i].value != var
&& TREE_CODE (copy_of[i].value) == SSA_NAME
&& POINTER_TYPE_P (TREE_TYPE (var))
&& SSA_NAME_PTR_INFO (var)
&& !SSA_NAME_PTR_INFO (copy_of[i].value))
duplicate_ssa_name_ptr_info (copy_of[i].value, SSA_NAME_PTR_INFO (var));
}
/* Don't do DCE if we have loops. That's the simplest way to not
destroy the scev cache. */
substitute_and_fold (get_value, NULL, !current_loops);
free (copy_of);
}
void
copy_ref_info (tree new_ref, tree old_ref)
{
tree new_ptr_base = NULL_TREE;
gcc_assert (TREE_CODE (new_ref) == MEM_REF
|| TREE_CODE (new_ref) == TARGET_MEM_REF);
TREE_SIDE_EFFECTS (new_ref) = TREE_SIDE_EFFECTS (old_ref);
TREE_THIS_VOLATILE (new_ref) = TREE_THIS_VOLATILE (old_ref);
new_ptr_base = TREE_OPERAND (new_ref, 0);
/* We can transfer points-to information from an old pointer
or decl base to the new one. */
if (new_ptr_base
&& TREE_CODE (new_ptr_base) == SSA_NAME
&& !SSA_NAME_PTR_INFO (new_ptr_base))
{
tree base = get_base_address (old_ref);
if (!base)
;
else if ((TREE_CODE (base) == MEM_REF
|| TREE_CODE (base) == TARGET_MEM_REF)
&& TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME
&& SSA_NAME_PTR_INFO (TREE_OPERAND (base, 0)))
{
struct ptr_info_def *new_pi;
unsigned int align, misalign;
duplicate_ssa_name_ptr_info
(new_ptr_base, SSA_NAME_PTR_INFO (TREE_OPERAND (base, 0)));
new_pi = SSA_NAME_PTR_INFO (new_ptr_base);
/* We have to be careful about transferring alignment information. */
if (get_ptr_info_alignment (new_pi, &align, &misalign)
&& TREE_CODE (old_ref) == MEM_REF
&& !(TREE_CODE (new_ref) == TARGET_MEM_REF
&& (TMR_INDEX2 (new_ref)
|| (TMR_STEP (new_ref)
&& (TREE_INT_CST_LOW (TMR_STEP (new_ref))
< align)))))
{
unsigned int inc = (mem_ref_offset (old_ref)
- mem_ref_offset (new_ref)).low;
adjust_ptr_info_misalignment (new_pi, inc);
}
else
mark_ptr_info_alignment_unknown (new_pi);
}
else if (TREE_CODE (base) == VAR_DECL
|| TREE_CODE (base) == PARM_DECL
|| TREE_CODE (base) == RESULT_DECL)
{
struct ptr_info_def *pi = get_ptr_info (new_ptr_base);
pt_solution_set_var (&pi->pt, base);
}
}
}
void
reset_flow_sensitive_info (tree name)
{
if (POINTER_TYPE_P (TREE_TYPE (name)))
{
/* points-to info is not flow-sensitive. */
if (SSA_NAME_PTR_INFO (name))
mark_ptr_info_alignment_unknown (SSA_NAME_PTR_INFO (name));
}
else
SSA_NAME_RANGE_INFO (name) = NULL;
}
struct ptr_info_def *
get_ptr_info (tree t)
{
struct ptr_info_def *pi;
gcc_assert (POINTER_TYPE_P (TREE_TYPE (t)));
pi = SSA_NAME_PTR_INFO (t);
if (pi == NULL)
{
pi = GGC_CNEW (struct ptr_info_def);
pt_solution_reset (&pi->pt);
SSA_NAME_PTR_INFO (t) = pi;
}
void
duplicate_ssa_name_ptr_info (tree name, struct ptr_info_def *ptr_info)
{
struct ptr_info_def *new_ptr_info;
gcc_assert (POINTER_TYPE_P (TREE_TYPE (name)));
gcc_assert (!SSA_NAME_PTR_INFO (name));
if (!ptr_info)
return;
new_ptr_info = ggc_alloc_ptr_info_def ();
*new_ptr_info = *ptr_info;
SSA_NAME_PTR_INFO (name) = new_ptr_info;
}
tree
make_ssa_name_fn (struct function *fn, tree var, gimple stmt)
{
tree t;
use_operand_p imm;
gcc_assert (TREE_CODE (var) == VAR_DECL
|| TREE_CODE (var) == PARM_DECL
|| TREE_CODE (var) == RESULT_DECL
|| (TYPE_P (var) && is_gimple_reg_type (var)));
/* If our free list has an element, then use it. */
if (!vec_safe_is_empty (FREE_SSANAMES (fn)))
{
t = FREE_SSANAMES (fn)->pop ();
if (GATHER_STATISTICS)
ssa_name_nodes_reused++;
/* The node was cleared out when we put it on the free list, so
there is no need to do so again here. */
gcc_assert (ssa_name (SSA_NAME_VERSION (t)) == NULL);
(*SSANAMES (fn))[SSA_NAME_VERSION (t)] = t;
}
else
{
t = make_node (SSA_NAME);
SSA_NAME_VERSION (t) = SSANAMES (fn)->length ();
vec_safe_push (SSANAMES (fn), t);
if (GATHER_STATISTICS)
ssa_name_nodes_created++;
}
if (TYPE_P (var))
{
TREE_TYPE (t) = var;
SET_SSA_NAME_VAR_OR_IDENTIFIER (t, NULL_TREE);
}
else
{
TREE_TYPE (t) = TREE_TYPE (var);
SET_SSA_NAME_VAR_OR_IDENTIFIER (t, var);
}
SSA_NAME_DEF_STMT (t) = stmt;
if (POINTER_TYPE_P (TREE_TYPE (t)))
SSA_NAME_PTR_INFO (t) = NULL;
else
SSA_NAME_RANGE_INFO (t) = NULL;
SSA_NAME_IN_FREE_LIST (t) = 0;
SSA_NAME_IS_DEFAULT_DEF (t) = 0;
imm = &(SSA_NAME_IMM_USE_NODE (t));
imm->use = NULL;
imm->prev = imm;
imm->next = imm;
imm->loc.ssa_name = t;
return t;
}
struct ptr_info_def *
get_ptr_info (tree t)
{
struct ptr_info_def *pi;
gcc_assert (POINTER_TYPE_P (TREE_TYPE (t)));
pi = SSA_NAME_PTR_INFO (t);
if (pi == NULL)
{
pi = ggc_alloc_cleared_ptr_info_def ();
pt_solution_reset (&pi->pt);
mark_ptr_info_alignment_unknown (pi);
SSA_NAME_PTR_INFO (t) = pi;
}
return pi;
}
static bool
ptr_deref_may_alias_decl_p (tree ptr, tree decl)
{
struct ptr_info_def *pi;
gcc_assert ((TREE_CODE (ptr) == SSA_NAME
|| TREE_CODE (ptr) == ADDR_EXPR
|| TREE_CODE (ptr) == INTEGER_CST)
&& (TREE_CODE (decl) == VAR_DECL
|| TREE_CODE (decl) == PARM_DECL
|| TREE_CODE (decl) == RESULT_DECL));
/* Non-aliased variables can not be pointed to. */
if (!may_be_aliased (decl))
return false;
/* ADDR_EXPR pointers either just offset another pointer or directly
specify the pointed-to set. */
if (TREE_CODE (ptr) == ADDR_EXPR)
{
tree base = get_base_address (TREE_OPERAND (ptr, 0));
if (base
&& INDIRECT_REF_P (base))
ptr = TREE_OPERAND (base, 0);
else if (base
&& SSA_VAR_P (base))
return operand_equal_p (base, decl, 0);
else if (base
&& CONSTANT_CLASS_P (base))
return false;
else
return true;
}
/* We can end up with dereferencing constant pointers.
Just bail out in this case. */
if (TREE_CODE (ptr) == INTEGER_CST)
return true;
/* If we do not have useful points-to information for this pointer
we cannot disambiguate anything else. */
pi = SSA_NAME_PTR_INFO (ptr);
if (!pi)
return true;
/* If the decl can be used as a restrict tag and we have a restrict
pointer and that pointers points-to set doesn't contain this decl
then they can't alias. */
if (DECL_RESTRICTED_P (decl)
&& TYPE_RESTRICT (TREE_TYPE (ptr))
&& pi->pt.vars_contains_restrict)
return bitmap_bit_p (pi->pt.vars, DECL_UID (decl));
return pt_solution_includes (&pi->pt, decl);
}
tree
duplicate_ssa_name_fn (struct function *fn, tree name, gimple stmt)
{
tree new_name = copy_ssa_name_fn (fn, name, stmt);
struct ptr_info_def *old_ptr_info = SSA_NAME_PTR_INFO (name);
if (old_ptr_info)
duplicate_ssa_name_ptr_info (new_name, old_ptr_info);
return new_name;
}
tree
duplicate_ssa_name (tree name, gimple stmt)
{
tree new_name = make_ssa_name (SSA_NAME_VAR (name), stmt);
struct ptr_info_def *old_ptr_info = SSA_NAME_PTR_INFO (name);
if (old_ptr_info)
duplicate_ssa_name_ptr_info (new_name, old_ptr_info);
return new_name;
}
void
duplicate_ssa_name_ptr_info (tree name, struct ptr_info_def *ptr_info)
{
struct ptr_info_def *new_ptr_info;
gcc_assert (POINTER_TYPE_P (TREE_TYPE (name)));
gcc_assert (!SSA_NAME_PTR_INFO (name));
if (!ptr_info)
return;
new_ptr_info = ggc_alloc (sizeof (struct ptr_info_def));
*new_ptr_info = *ptr_info;
if (ptr_info->pt_vars)
{
new_ptr_info->pt_vars = BITMAP_GGC_ALLOC ();
bitmap_copy (new_ptr_info->pt_vars, ptr_info->pt_vars);
}
SSA_NAME_PTR_INFO (name) = new_ptr_info;
}
tree
make_ssa_name (tree var, tree stmt)
{
tree t;
use_operand_p imm;
gcc_assert (DECL_P (var)
|| TREE_CODE (var) == INDIRECT_REF);
gcc_assert (!stmt
|| EXPR_P (stmt) || GIMPLE_STMT_P (stmt)
|| TREE_CODE (stmt) == PHI_NODE);
/* If our free list has an element, then use it. */
if (FREE_SSANAMES (cfun))
{
t = FREE_SSANAMES (cfun);
FREE_SSANAMES (cfun) = TREE_CHAIN (FREE_SSANAMES (cfun));
#ifdef GATHER_STATISTICS
ssa_name_nodes_reused++;
#endif
/* The node was cleared out when we put it on the free list, so
there is no need to do so again here. */
gcc_assert (ssa_name (SSA_NAME_VERSION (t)) == NULL);
VEC_replace (tree, SSANAMES (cfun), SSA_NAME_VERSION (t), t);
}
else
{
t = make_node (SSA_NAME);
SSA_NAME_VERSION (t) = num_ssa_names;
VEC_safe_push (tree, gc, SSANAMES (cfun), t);
#ifdef GATHER_STATISTICS
ssa_name_nodes_created++;
#endif
}
TREE_TYPE (t) = TREE_TYPE (var);
SSA_NAME_VAR (t) = var;
SSA_NAME_DEF_STMT (t) = stmt;
SSA_NAME_PTR_INFO (t) = NULL;
SSA_NAME_IN_FREE_LIST (t) = 0;
SSA_NAME_IS_DEFAULT_DEF (t) = 0;
imm = &(SSA_NAME_IMM_USE_NODE (t));
imm->use = NULL;
imm->prev = imm;
imm->next = imm;
imm->stmt = t;
return t;
}
static void
fini_copy_prop (void)
{
size_t i;
prop_value_t *tmp;
/* Set the final copy-of value for each variable by traversing the
copy-of chains. */
tmp = XCNEWVEC (prop_value_t, num_ssa_names);
for (i = 1; i < num_ssa_names; i++)
{
tree var = ssa_name (i);
if (!var
|| !copy_of[i].value
|| copy_of[i].value == var)
continue;
tmp[i].value = get_last_copy_of (var);
/* In theory the points-to solution of all members of the
copy chain is their intersection. For now we do not bother
to compute this but only make sure we do not lose points-to
information completely by setting the points-to solution
of the representative to the first solution we find if
it doesn't have one already. */
if (tmp[i].value != var
&& POINTER_TYPE_P (TREE_TYPE (var))
&& SSA_NAME_PTR_INFO (var)
&& !SSA_NAME_PTR_INFO (tmp[i].value))
duplicate_ssa_name_ptr_info (tmp[i].value, SSA_NAME_PTR_INFO (var));
}
substitute_and_fold (tmp, false);
free (cached_last_copy_of);
free (copy_of);
free (tmp);
}
tree
make_ssa_name_fn (struct function *fn, tree var, gimple stmt)
{
tree t;
use_operand_p imm;
gcc_assert (DECL_P (var));
/* If our free list has an element, then use it. */
if (FREE_SSANAMES (fn))
{
t = FREE_SSANAMES (fn);
FREE_SSANAMES (fn) = TREE_CHAIN (FREE_SSANAMES (fn));
#ifdef GATHER_STATISTICS
ssa_name_nodes_reused++;
#endif
/* The node was cleared out when we put it on the free list, so
there is no need to do so again here. */
gcc_assert (ssa_name (SSA_NAME_VERSION (t)) == NULL);
VEC_replace (tree, SSANAMES (fn), SSA_NAME_VERSION (t), t);
}
else
{
t = make_node (SSA_NAME);
SSA_NAME_VERSION (t) = VEC_length (tree, SSANAMES (fn));
VEC_safe_push (tree, gc, SSANAMES (fn), t);
#ifdef GATHER_STATISTICS
ssa_name_nodes_created++;
#endif
}
TREE_TYPE (t) = TREE_TYPE (var);
SSA_NAME_VAR (t) = var;
SSA_NAME_DEF_STMT (t) = stmt;
SSA_NAME_PTR_INFO (t) = NULL;
SSA_NAME_IN_FREE_LIST (t) = 0;
SSA_NAME_IS_DEFAULT_DEF (t) = 0;
imm = &(SSA_NAME_IMM_USE_NODE (t));
imm->use = NULL;
imm->prev = imm;
imm->next = imm;
imm->loc.ssa_name = t;
return t;
}
void
dump_alias_info (FILE *file)
{
size_t i;
const char *funcname
= lang_hooks.decl_printable_name (current_function_decl, 2);
referenced_var_iterator rvi;
tree var;
fprintf (file, "\n\nAlias information for %s\n\n", funcname);
fprintf (file, "Aliased symbols\n\n");
FOR_EACH_REFERENCED_VAR (var, rvi)
{
if (may_be_aliased (var))
dump_variable (file, var);
}
fprintf (file, "\nCall clobber information\n");
fprintf (file, "\nESCAPED");
dump_points_to_solution (file, &cfun->gimple_df->escaped);
fprintf (file, "\nCALLUSED");
dump_points_to_solution (file, &cfun->gimple_df->callused);
fprintf (file, "\n\nFlow-insensitive points-to information\n\n");
for (i = 1; i < num_ssa_names; i++)
{
tree ptr = ssa_name (i);
struct ptr_info_def *pi;
if (ptr == NULL_TREE
|| SSA_NAME_IN_FREE_LIST (ptr))
continue;
pi = SSA_NAME_PTR_INFO (ptr);
if (pi)
dump_points_to_info_for (file, ptr);
}
fprintf (file, "\n");
}
wide_int
get_nonzero_bits (const_tree name)
{
unsigned int precision = TYPE_PRECISION (TREE_TYPE (name));
if (POINTER_TYPE_P (TREE_TYPE (name)))
{
struct ptr_info_def *pi = SSA_NAME_PTR_INFO (name);
if (pi && pi->align)
return wi::shwi (-(HOST_WIDE_INT) pi->align
| (HOST_WIDE_INT) pi->misalign, precision);
return wi::shwi (-1, precision);
}
range_info_def *ri = SSA_NAME_RANGE_INFO (name);
if (!ri)
return wi::shwi (-1, precision);
return ri->get_nonzero_bits ();
}
bool
ptr_deref_may_alias_global_p (tree ptr)
{
struct ptr_info_def *pi;
/* If we end up with a pointer constant here that may point
to global memory. */
if (TREE_CODE (ptr) != SSA_NAME)
return true;
pi = SSA_NAME_PTR_INFO (ptr);
/* If we do not have points-to information for this variable,
we have to punt. */
if (!pi)
return true;
/* ??? This does not use TBAA to prune globals ptr may not access. */
return pt_solution_includes_global (&pi->pt);
}
tree
duplicate_ssa_name_fn (struct function *fn, tree name, gimple stmt)
{
tree new_name = copy_ssa_name_fn (fn, name, stmt);
if (POINTER_TYPE_P (TREE_TYPE (name)))
{
struct ptr_info_def *old_ptr_info = SSA_NAME_PTR_INFO (name);
if (old_ptr_info)
duplicate_ssa_name_ptr_info (new_name, old_ptr_info);
}
else
{
struct range_info_def *old_range_info = SSA_NAME_RANGE_INFO (name);
if (old_range_info)
duplicate_ssa_name_range_info (new_name, old_range_info);
}
return new_name;
}
double_int
get_nonzero_bits (const_tree name)
{
if (POINTER_TYPE_P (TREE_TYPE (name)))
{
struct ptr_info_def *pi = SSA_NAME_PTR_INFO (name);
if (pi && pi->align)
{
double_int al = double_int::from_uhwi (pi->align - 1);
return ((double_int::mask (TYPE_PRECISION (TREE_TYPE (name))) & ~al)
| double_int::from_uhwi (pi->misalign));
}
return double_int_minus_one;
}
range_info_def *ri = SSA_NAME_RANGE_INFO (name);
if (!ri || (GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (name)))
> 2 * HOST_BITS_PER_WIDE_INT))
return double_int_minus_one;
return ri->nonzero_bits;
}
static bool
fini_copy_prop (void)
{
unsigned i;
/* Set the final copy-of value for each variable by traversing the
copy-of chains. */
for (i = 1; i < num_ssa_names; i++)
{
tree var = ssa_name (i);
if (!var
|| !copy_of[i].value
|| copy_of[i].value == var)
continue;
/* In theory the points-to solution of all members of the
copy chain is their intersection. For now we do not bother
to compute this but only make sure we do not lose points-to
information completely by setting the points-to solution
of the representative to the first solution we find if
it doesn't have one already. */
if (copy_of[i].value != var
&& TREE_CODE (copy_of[i].value) == SSA_NAME)
{
basic_block copy_of_bb
= gimple_bb (SSA_NAME_DEF_STMT (copy_of[i].value));
basic_block var_bb = gimple_bb (SSA_NAME_DEF_STMT (var));
if (POINTER_TYPE_P (TREE_TYPE (var))
&& SSA_NAME_PTR_INFO (var)
&& !SSA_NAME_PTR_INFO (copy_of[i].value))
{
duplicate_ssa_name_ptr_info (copy_of[i].value,
SSA_NAME_PTR_INFO (var));
/* Points-to information is cfg insensitive,
but alignment info might be cfg sensitive, if it
e.g. is derived from VRP derived non-zero bits.
So, do not copy alignment info if the two SSA_NAMEs
aren't defined in the same basic block. */
if (var_bb != copy_of_bb)
mark_ptr_info_alignment_unknown
(SSA_NAME_PTR_INFO (copy_of[i].value));
}
else if (!POINTER_TYPE_P (TREE_TYPE (var))
&& SSA_NAME_RANGE_INFO (var)
&& !SSA_NAME_RANGE_INFO (copy_of[i].value)
&& var_bb == copy_of_bb)
duplicate_ssa_name_range_info (copy_of[i].value,
SSA_NAME_RANGE_TYPE (var),
SSA_NAME_RANGE_INFO (var));
}
}
bool changed = substitute_and_fold (get_value, NULL, true);
if (changed)
{
free_numbers_of_iterations_estimates ();
if (scev_initialized_p ())
scev_reset ();
}
free (copy_of);
return changed;
}
static bool
ptr_derefs_may_alias_p (tree ptr1, tree ptr2)
{
struct ptr_info_def *pi1, *pi2;
gcc_assert ((TREE_CODE (ptr1) == SSA_NAME
|| TREE_CODE (ptr1) == ADDR_EXPR
|| TREE_CODE (ptr1) == INTEGER_CST)
&& (TREE_CODE (ptr2) == SSA_NAME
|| TREE_CODE (ptr2) == ADDR_EXPR
|| TREE_CODE (ptr2) == INTEGER_CST));
/* ADDR_EXPR pointers either just offset another pointer or directly
specify the pointed-to set. */
if (TREE_CODE (ptr1) == ADDR_EXPR)
{
tree base = get_base_address (TREE_OPERAND (ptr1, 0));
if (base
&& INDIRECT_REF_P (base))
ptr1 = TREE_OPERAND (base, 0);
else if (base
&& SSA_VAR_P (base))
return ptr_deref_may_alias_decl_p (ptr2, base);
else
return true;
}
if (TREE_CODE (ptr2) == ADDR_EXPR)
{
tree base = get_base_address (TREE_OPERAND (ptr2, 0));
if (base
&& INDIRECT_REF_P (base))
ptr2 = TREE_OPERAND (base, 0);
else if (base
&& SSA_VAR_P (base))
return ptr_deref_may_alias_decl_p (ptr1, base);
else
return true;
}
/* We can end up with dereferencing constant pointers.
Just bail out in this case. */
if (TREE_CODE (ptr1) == INTEGER_CST
|| TREE_CODE (ptr2) == INTEGER_CST)
return true;
/* We may end up with two empty points-to solutions for two same pointers.
In this case we still want to say both pointers alias, so shortcut
that here. */
if (ptr1 == ptr2)
return true;
/* If we do not have useful points-to information for either pointer
we cannot disambiguate anything else. */
pi1 = SSA_NAME_PTR_INFO (ptr1);
pi2 = SSA_NAME_PTR_INFO (ptr2);
if (!pi1 || !pi2)
return true;
/* If both pointers are restrict-qualified try to disambiguate
with restrict information. */
if (TYPE_RESTRICT (TREE_TYPE (ptr1))
&& TYPE_RESTRICT (TREE_TYPE (ptr2))
&& !pt_solutions_same_restrict_base (&pi1->pt, &pi2->pt))
return false;
/* ??? This does not use TBAA to prune decls from the intersection
that not both pointers may access. */
return pt_solutions_intersect (&pi1->pt, &pi2->pt);
}
void
merge_alias_info (tree orig_name, tree new_name)
{
tree new_sym = SSA_NAME_VAR (new_name);
tree orig_sym = SSA_NAME_VAR (orig_name);
var_ann_t new_ann = var_ann (new_sym);
var_ann_t orig_ann = var_ann (orig_sym);
/* No merging necessary when memory partitions are involved. */
if (factoring_name_p (new_name))
{
gcc_assert (!is_gimple_reg (orig_sym));
return;
}
else if (factoring_name_p (orig_name))
{
gcc_assert (!is_gimple_reg (new_sym));
return;
}
gcc_assert (POINTER_TYPE_P (TREE_TYPE (orig_name))
&& POINTER_TYPE_P (TREE_TYPE (new_name)));
#if defined ENABLE_CHECKING
gcc_assert (useless_type_conversion_p (TREE_TYPE (orig_name),
TREE_TYPE (new_name)));
/* Check that flow-sensitive information is compatible. Notice that
we may not merge flow-sensitive information here. This function
is called when propagating equivalences dictated by the IL, like
a copy operation P_i = Q_j, and from equivalences dictated by
control-flow, like if (P_i == Q_j).
In the former case, P_i and Q_j are equivalent in every block
dominated by the assignment, so their flow-sensitive information
is always the same. However, in the latter case, the pointers
P_i and Q_j are only equivalent in one of the sub-graphs out of
the predicate, so their flow-sensitive information is not the
same in every block dominated by the predicate.
Since we cannot distinguish one case from another in this
function, we can only make sure that if P_i and Q_j have
flow-sensitive information, they should be compatible.
As callers of merge_alias_info are supposed to call may_propagate_copy
first, the following check is redundant. Thus, only do it if checking
is enabled. */
if (SSA_NAME_PTR_INFO (orig_name) && SSA_NAME_PTR_INFO (new_name))
{
struct ptr_info_def *orig_ptr_info = SSA_NAME_PTR_INFO (orig_name);
struct ptr_info_def *new_ptr_info = SSA_NAME_PTR_INFO (new_name);
/* Note that pointer NEW and ORIG may actually have different
pointed-to variables (e.g., PR 18291 represented in
testsuite/gcc.c-torture/compile/pr18291.c). However, since
NEW is being copy-propagated into ORIG, it must always be
true that the pointed-to set for pointer NEW is the same, or
a subset, of the pointed-to set for pointer ORIG. If this
isn't the case, we shouldn't have been able to do the
propagation of NEW into ORIG. */
if (orig_ptr_info->name_mem_tag
&& new_ptr_info->name_mem_tag
&& orig_ptr_info->pt_vars
&& new_ptr_info->pt_vars)
gcc_assert (bitmap_intersect_p (new_ptr_info->pt_vars,
orig_ptr_info->pt_vars));
}
#endif
/* Synchronize the symbol tags. If both pointers had a tag and they
are different, then something has gone wrong. Symbol tags can
always be merged because they are flow insensitive, all the SSA
names of the same base DECL share the same symbol tag. */
if (new_ann->symbol_mem_tag == NULL_TREE)
new_ann->symbol_mem_tag = orig_ann->symbol_mem_tag;
else if (orig_ann->symbol_mem_tag == NULL_TREE)
orig_ann->symbol_mem_tag = new_ann->symbol_mem_tag;
else
gcc_assert (new_ann->symbol_mem_tag == orig_ann->symbol_mem_tag);
/* Copy flow-sensitive alias information in case that NEW_NAME
didn't get a NMT but was set to pt_anything for optimization
purposes. In case ORIG_NAME has a NMT we can safely use its
flow-sensitive alias information as a conservative estimate. */
if (SSA_NAME_PTR_INFO (orig_name)
&& SSA_NAME_PTR_INFO (orig_name)->name_mem_tag
&& (!SSA_NAME_PTR_INFO (new_name)
|| !SSA_NAME_PTR_INFO (new_name)->name_mem_tag))
{
struct ptr_info_def *orig_ptr_info = SSA_NAME_PTR_INFO (orig_name);
struct ptr_info_def *new_ptr_info = get_ptr_info (new_name);
memcpy (new_ptr_info, orig_ptr_info, sizeof (struct ptr_info_def));
}
}
bool
may_propagate_copy (tree dest, tree orig)
{
tree type_d = TREE_TYPE (dest);
tree type_o = TREE_TYPE (orig);
/* Do not copy between types for which we *do* need a conversion. */
if (!tree_ssa_useless_type_conversion_1 (type_d, type_o))
return false;
/* FIXME. GIMPLE is allowing pointer assignments and comparisons of
pointers that have different alias sets. This means that these
pointers will have different memory tags associated to them.
If we allow copy propagation in these cases, statements de-referencing
the new pointer will now have a reference to a different memory tag
with potentially incorrect SSA information.
This was showing up in libjava/java/util/zip/ZipFile.java with code
like:
struct java.io.BufferedInputStream *T.660;
struct java.io.BufferedInputStream *T.647;
struct java.io.InputStream *is;
struct java.io.InputStream *is.662;
[ ... ]
T.660 = T.647;
is = T.660; <-- This ought to be type-casted
is.662 = is;
Also, f/name.c exposed a similar problem with a COND_EXPR predicate
that was causing DOM to generate and equivalence with two pointers of
alias-incompatible types:
struct _ffename_space *n;
struct _ffename *ns;
[ ... ]
if (n == ns)
goto lab;
...
lab:
return n;
I think that GIMPLE should emit the appropriate type-casts. For the
time being, blocking copy-propagation in these cases is the safe thing
to do. */
if (TREE_CODE (dest) == SSA_NAME
&& TREE_CODE (orig) == SSA_NAME
&& POINTER_TYPE_P (type_d)
&& POINTER_TYPE_P (type_o))
{
tree mt_dest = var_ann (SSA_NAME_VAR (dest))->symbol_mem_tag;
tree mt_orig = var_ann (SSA_NAME_VAR (orig))->symbol_mem_tag;
if (mt_dest && mt_orig && mt_dest != mt_orig)
return false;
else if (!lang_hooks.types_compatible_p (type_d, type_o))
return false;
else if (get_alias_set (TREE_TYPE (type_d)) !=
get_alias_set (TREE_TYPE (type_o)))
return false;
/* Also verify flow-sensitive information is compatible. */
if (SSA_NAME_PTR_INFO (orig) && SSA_NAME_PTR_INFO (dest))
{
struct ptr_info_def *orig_ptr_info = SSA_NAME_PTR_INFO (orig);
struct ptr_info_def *dest_ptr_info = SSA_NAME_PTR_INFO (dest);
if (orig_ptr_info->name_mem_tag
&& dest_ptr_info->name_mem_tag
&& orig_ptr_info->pt_vars
&& dest_ptr_info->pt_vars
&& !bitmap_intersect_p (dest_ptr_info->pt_vars,
orig_ptr_info->pt_vars))
return false;
}
}
/* If the destination is a SSA_NAME for a virtual operand, then we have
some special cases to handle. */
if (TREE_CODE (dest) == SSA_NAME && !is_gimple_reg (dest))
{
/* If both operands are SSA_NAMEs referring to virtual operands, then
we can always propagate. */
if (TREE_CODE (orig) == SSA_NAME
&& !is_gimple_reg (orig))
return true;
/* We have a "copy" from something like a constant into a virtual
operand. Reject these. */
return false;
}
/* If ORIG flows in from an abnormal edge, it cannot be propagated. */
if (TREE_CODE (orig) == SSA_NAME
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (orig))
return false;
/* If DEST is an SSA_NAME that flows from an abnormal edge, then it
cannot be replaced. */
if (TREE_CODE (dest) == SSA_NAME
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (dest))
return false;
/* Anything else is OK. */
return true;
}
