modref_access_node cleanup
move member functions of modref_access_node from ipa-modref-tree.h to ipa-modref-tree.c since they become long and not fitting for inlines anyway. I also cleaned up the interface by making static insert method (which handles inserting accesses into a vector and optimizing them) which makes it possible to hide most of the interface handling interval merging private. Honza gcc/ChangeLog: * ipa-modref-tree.h (struct modref_access_node): Move longer member functions to ipa-modref-tree.c (modref_ref_node::try_merge_with): Turn into modreef_acces_node member function. * ipa-modref-tree.c (modref_access_node::contains): Move here from ipa-modref-tree.h. (modref_access_node::update): Likewise. (modref_access_node::merge): Likewise. (modref_access_node::closer_pair_p): Likewise. (modref_access_node::forced_merge): Likewise. (modref_access_node::update2): Likewise. (modref_access_node::combined_offsets): Likewise. (modref_access_node::try_merge_with): Likewise. (modref_access_node::insert): Likewise.
This commit is contained in:
Jan Hubicka
parent
e0040bc3d9
commit
a246d7230b
|
|
@ -28,6 +28,541 @@ along with GCC; see the file COPYING3. If not see
|
|||
|
||||
#if CHECKING_P
|
||||
|
||||
/* Return true if both accesses are the same. */
|
||||
bool
|
||||
modref_access_node::operator == (modref_access_node &a) const
|
||||
{
|
||||
if (parm_index != a.parm_index)
|
||||
return false;
|
||||
if (parm_index != MODREF_UNKNOWN_PARM)
|
||||
{
|
||||
if (parm_offset_known != a.parm_offset_known)
|
||||
return false;
|
||||
if (parm_offset_known
|
||||
&& !known_eq (parm_offset, a.parm_offset))
|
||||
return false;
|
||||
}
|
||||
if (range_info_useful_p () != a.range_info_useful_p ())
|
||||
return false;
|
||||
if (range_info_useful_p ()
|
||||
&& (!known_eq (a.offset, offset)
|
||||
|| !known_eq (a.size, size)
|
||||
|| !known_eq (a.max_size, max_size)))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Return true A is a subaccess. */
|
||||
bool
|
||||
modref_access_node::contains (const modref_access_node &a) const
|
||||
{
|
||||
poly_int64 aoffset_adj = 0;
|
||||
if (parm_index != MODREF_UNKNOWN_PARM)
|
||||
{
|
||||
if (parm_index != a.parm_index)
|
||||
return false;
|
||||
if (parm_offset_known)
|
||||
{
|
||||
if (!a.parm_offset_known)
|
||||
return false;
|
||||
/* Accesses are never below parm_offset, so look
|
||||
for smaller offset.
|
||||
If access ranges are known still allow merging
|
||||
when bit offsets comparsion passes. */
|
||||
if (!known_le (parm_offset, a.parm_offset)
|
||||
&& !range_info_useful_p ())
|
||||
return false;
|
||||
/* We allow negative aoffset_adj here in case
|
||||
there is an useful range. This is because adding
|
||||
a.offset may result in non-ngative offset again.
|
||||
Ubsan fails on val << LOG_BITS_PER_UNIT where val
|
||||
is negative. */
|
||||
aoffset_adj = (a.parm_offset - parm_offset)
|
||||
* BITS_PER_UNIT;
|
||||
}
|
||||
}
|
||||
if (range_info_useful_p ())
|
||||
{
|
||||
if (!a.range_info_useful_p ())
|
||||
return false;
|
||||
/* Sizes of stores are used to check that object is big enough
|
||||
to fit the store, so smaller or unknown sotre is more general
|
||||
than large store. */
|
||||
if (known_size_p (size)
|
||||
&& (!known_size_p (a.size)
|
||||
|| !known_le (size, a.size)))
|
||||
return false;
|
||||
if (known_size_p (max_size))
|
||||
return known_subrange_p (a.offset + aoffset_adj,
|
||||
a.max_size, offset, max_size);
|
||||
else
|
||||
return known_le (offset, a.offset + aoffset_adj);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Update access range to new parameters.
|
||||
If RECORD_ADJUSTMENTS is true, record number of changes in the access
|
||||
and if threshold is exceeded start dropping precision
|
||||
so only constantly many updates are possible. This makes dataflow
|
||||
to converge. */
|
||||
void
|
||||
modref_access_node::update (poly_int64 parm_offset1,
|
||||
poly_int64 offset1, poly_int64 size1,
|
||||
poly_int64 max_size1, bool record_adjustments)
|
||||
{
|
||||
if (known_eq (parm_offset, parm_offset1)
|
||||
&& known_eq (offset, offset1)
|
||||
&& known_eq (size, size1)
|
||||
&& known_eq (max_size, max_size1))
|
||||
return;
|
||||
if (!record_adjustments
|
||||
|| (++adjustments) < param_modref_max_adjustments)
|
||||
{
|
||||
parm_offset = parm_offset1;
|
||||
offset = offset1;
|
||||
size = size1;
|
||||
max_size = max_size1;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (dump_file)
|
||||
fprintf (dump_file,
|
||||
"--param param=modref-max-adjustments limit reached:");
|
||||
if (!known_eq (parm_offset, parm_offset1))
|
||||
{
|
||||
if (dump_file)
|
||||
fprintf (dump_file, " parm_offset cleared");
|
||||
parm_offset_known = false;
|
||||
}
|
||||
if (!known_eq (size, size1))
|
||||
{
|
||||
size = -1;
|
||||
if (dump_file)
|
||||
fprintf (dump_file, " size cleared");
|
||||
}
|
||||
if (!known_eq (max_size, max_size1))
|
||||
{
|
||||
max_size = -1;
|
||||
if (dump_file)
|
||||
fprintf (dump_file, " max_size cleared");
|
||||
}
|
||||
if (!known_eq (offset, offset1))
|
||||
{
|
||||
offset = 0;
|
||||
if (dump_file)
|
||||
fprintf (dump_file, " offset cleared");
|
||||
}
|
||||
if (dump_file)
|
||||
fprintf (dump_file, "\n");
|
||||
}
|
||||
}
|
||||
|
||||
/* Merge in access A if it is possible to do without losing
|
||||
precision. Return true if successful.
|
||||
If RECORD_ADJUSTMENTs is true, remember how many interval
|
||||
was prolonged and punt when there are too many. */
|
||||
bool
|
||||
modref_access_node::merge (const modref_access_node &a,
|
||||
bool record_adjustments)
|
||||
{
|
||||
poly_int64 offset1 = 0;
|
||||
poly_int64 aoffset1 = 0;
|
||||
poly_int64 new_parm_offset = 0;
|
||||
|
||||
/* We assume that containment was tested earlier. */
|
||||
gcc_checking_assert (!contains (a) && !a.contains (*this));
|
||||
if (parm_index != MODREF_UNKNOWN_PARM)
|
||||
{
|
||||
if (parm_index != a.parm_index)
|
||||
return false;
|
||||
if (parm_offset_known)
|
||||
{
|
||||
if (!a.parm_offset_known)
|
||||
return false;
|
||||
if (!combined_offsets (a, &new_parm_offset, &offset1, &aoffset1))
|
||||
return false;
|
||||
}
|
||||
}
|
||||
/* See if we can merge ranges. */
|
||||
if (range_info_useful_p ())
|
||||
{
|
||||
/* In this case we have containment that should be
|
||||
handled earlier. */
|
||||
gcc_checking_assert (a.range_info_useful_p ());
|
||||
|
||||
/* If a.size is less specified than size, merge only
|
||||
if intervals are otherwise equivalent. */
|
||||
if (known_size_p (size)
|
||||
&& (!known_size_p (a.size) || known_lt (a.size, size)))
|
||||
{
|
||||
if (((known_size_p (max_size) || known_size_p (a.max_size))
|
||||
&& !known_eq (max_size, a.max_size))
|
||||
|| !known_eq (offset1, aoffset1))
|
||||
return false;
|
||||
update (new_parm_offset, offset1, a.size, max_size,
|
||||
record_adjustments);
|
||||
return true;
|
||||
}
|
||||
/* If sizes are same, we can extend the interval. */
|
||||
if ((known_size_p (size) || known_size_p (a.size))
|
||||
&& !known_eq (size, a.size))
|
||||
return false;
|
||||
if (known_le (offset1, aoffset1))
|
||||
{
|
||||
if (!known_size_p (max_size)
|
||||
|| known_ge (offset1 + max_size, aoffset1))
|
||||
{
|
||||
update2 (new_parm_offset, offset1, size, max_size,
|
||||
aoffset1, a.size, a.max_size,
|
||||
record_adjustments);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
else if (known_le (aoffset1, offset1))
|
||||
{
|
||||
if (!known_size_p (a.max_size)
|
||||
|| known_ge (aoffset1 + a.max_size, offset1))
|
||||
{
|
||||
update2 (new_parm_offset, offset1, size, max_size,
|
||||
aoffset1, a.size, a.max_size,
|
||||
record_adjustments);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
update (new_parm_offset, offset1,
|
||||
size, max_size, record_adjustments);
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Return true if A1 and B1 can be merged with lower information
|
||||
less than A2 and B2.
|
||||
Assume that no containment or lossless merging is possible. */
|
||||
bool
|
||||
modref_access_node::closer_pair_p (const modref_access_node &a1,
|
||||
const modref_access_node &b1,
|
||||
const modref_access_node &a2,
|
||||
const modref_access_node &b2)
|
||||
{
|
||||
/* Merging different parm indexes comes to complete loss
|
||||
of range info. */
|
||||
if (a1.parm_index != b1.parm_index)
|
||||
return false;
|
||||
if (a2.parm_index != b2.parm_index)
|
||||
return true;
|
||||
/* If parm is known and parm indexes are the same we should
|
||||
already have containment. */
|
||||
gcc_checking_assert (a1.parm_offset_known && b1.parm_offset_known);
|
||||
gcc_checking_assert (a2.parm_offset_known && b2.parm_offset_known);
|
||||
|
||||
/* First normalize offsets for parm offsets. */
|
||||
poly_int64 new_parm_offset, offseta1, offsetb1, offseta2, offsetb2;
|
||||
if (!a1.combined_offsets (b1, &new_parm_offset, &offseta1, &offsetb1)
|
||||
|| !a2.combined_offsets (b2, &new_parm_offset, &offseta2, &offsetb2))
|
||||
gcc_unreachable ();
|
||||
|
||||
|
||||
/* Now compute distnace of the intervals. */
|
||||
poly_int64 dist1, dist2;
|
||||
if (known_le (offseta1, offsetb1))
|
||||
{
|
||||
if (!known_size_p (a1.max_size))
|
||||
dist1 = 0;
|
||||
else
|
||||
dist1 = offsetb1 - offseta1 - a1.max_size;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!known_size_p (b1.max_size))
|
||||
dist1 = 0;
|
||||
else
|
||||
dist1 = offseta1 - offsetb1 - b1.max_size;
|
||||
}
|
||||
if (known_le (offseta2, offsetb2))
|
||||
{
|
||||
if (!known_size_p (a2.max_size))
|
||||
dist2 = 0;
|
||||
else
|
||||
dist2 = offsetb2 - offseta2 - a2.max_size;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!known_size_p (b2.max_size))
|
||||
dist2 = 0;
|
||||
else
|
||||
dist2 = offseta2 - offsetb2 - b2.max_size;
|
||||
}
|
||||
/* It may happen that intervals overlap in case size
|
||||
is different. Preffer the overlap to non-overlap. */
|
||||
if (known_lt (dist1, 0) && known_ge (dist2, 0))
|
||||
return true;
|
||||
if (known_lt (dist2, 0) && known_ge (dist1, 0))
|
||||
return false;
|
||||
if (known_lt (dist1, 0))
|
||||
/* If both overlaps minimize overlap. */
|
||||
return known_le (dist2, dist1);
|
||||
else
|
||||
/* If both are disjoint look for smaller distance. */
|
||||
return known_le (dist1, dist2);
|
||||
}
|
||||
|
||||
/* Merge in access A while losing precision. */
|
||||
void
|
||||
modref_access_node::forced_merge (const modref_access_node &a,
|
||||
bool record_adjustments)
|
||||
{
|
||||
if (parm_index != a.parm_index)
|
||||
{
|
||||
gcc_checking_assert (parm_index != MODREF_UNKNOWN_PARM);
|
||||
parm_index = MODREF_UNKNOWN_PARM;
|
||||
return;
|
||||
}
|
||||
|
||||
/* We assume that containment and lossless merging
|
||||
was tested earlier. */
|
||||
gcc_checking_assert (!contains (a) && !a.contains (*this)
|
||||
&& !merge (a, record_adjustments));
|
||||
gcc_checking_assert (parm_offset_known && a.parm_offset_known);
|
||||
|
||||
poly_int64 new_parm_offset, offset1, aoffset1;
|
||||
if (!combined_offsets (a, &new_parm_offset, &offset1, &aoffset1))
|
||||
{
|
||||
parm_offset_known = false;
|
||||
return;
|
||||
}
|
||||
gcc_checking_assert (range_info_useful_p ()
|
||||
&& a.range_info_useful_p ());
|
||||
if (record_adjustments)
|
||||
adjustments += a.adjustments;
|
||||
update2 (new_parm_offset,
|
||||
offset1, size, max_size,
|
||||
aoffset1, a.size, a.max_size,
|
||||
record_adjustments);
|
||||
}
|
||||
|
||||
/* Merge two ranges both starting at parm_offset1 and update THIS
|
||||
with result. */
|
||||
void
|
||||
modref_access_node::update2 (poly_int64 parm_offset1,
|
||||
poly_int64 offset1, poly_int64 size1,
|
||||
poly_int64 max_size1,
|
||||
poly_int64 offset2, poly_int64 size2,
|
||||
poly_int64 max_size2,
|
||||
bool record_adjustments)
|
||||
{
|
||||
poly_int64 new_size = size1;
|
||||
|
||||
if (!known_size_p (size2)
|
||||
|| known_le (size2, size1))
|
||||
new_size = size2;
|
||||
else
|
||||
gcc_checking_assert (known_le (size1, size2));
|
||||
|
||||
if (known_le (offset1, offset2))
|
||||
;
|
||||
else if (known_le (offset2, offset1))
|
||||
{
|
||||
std::swap (offset1, offset2);
|
||||
std::swap (max_size1, max_size2);
|
||||
}
|
||||
else
|
||||
gcc_unreachable ();
|
||||
|
||||
poly_int64 new_max_size;
|
||||
|
||||
if (!known_size_p (max_size1))
|
||||
new_max_size = max_size1;
|
||||
else if (!known_size_p (max_size2))
|
||||
new_max_size = max_size2;
|
||||
else
|
||||
{
|
||||
new_max_size = max_size2 + offset2 - offset1;
|
||||
if (known_le (new_max_size, max_size1))
|
||||
new_max_size = max_size1;
|
||||
}
|
||||
|
||||
update (parm_offset1, offset1,
|
||||
new_size, new_max_size, record_adjustments);
|
||||
}
|
||||
|
||||
/* Given access nodes THIS and A, return true if they
|
||||
can be done with common parm_offsets. In this case
|
||||
return parm offset in new_parm_offset, new_offset
|
||||
which is start of range in THIS and new_aoffset that
|
||||
is start of range in A. */
|
||||
bool
|
||||
modref_access_node::combined_offsets (const modref_access_node &a,
|
||||
poly_int64 *new_parm_offset,
|
||||
poly_int64 *new_offset,
|
||||
poly_int64 *new_aoffset) const
|
||||
{
|
||||
gcc_checking_assert (parm_offset_known && a.parm_offset_known);
|
||||
if (known_le (a.parm_offset, parm_offset))
|
||||
{
|
||||
*new_offset = offset
|
||||
+ ((parm_offset - a.parm_offset)
|
||||
<< LOG2_BITS_PER_UNIT);
|
||||
*new_aoffset = a.offset;
|
||||
*new_parm_offset = a.parm_offset;
|
||||
return true;
|
||||
}
|
||||
else if (known_le (parm_offset, a.parm_offset))
|
||||
{
|
||||
*new_aoffset = a.offset
|
||||
+ ((a.parm_offset - parm_offset)
|
||||
<< LOG2_BITS_PER_UNIT);
|
||||
*new_offset = offset;
|
||||
*new_parm_offset = parm_offset;
|
||||
return true;
|
||||
}
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Try to optimize the access ACCESSES list after entry INDEX was modified. */
|
||||
void
|
||||
modref_access_node::try_merge_with (vec <modref_access_node, va_gc> *&accesses,
|
||||
size_t index)
|
||||
{
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < accesses->length ();)
|
||||
if (i != index)
|
||||
{
|
||||
bool found = false, restart = false;
|
||||
modref_access_node *a = &(*accesses)[i];
|
||||
modref_access_node *n = &(*accesses)[index];
|
||||
|
||||
if (n->contains (*a))
|
||||
found = true;
|
||||
if (!found && n->merge (*a, false))
|
||||
found = restart = true;
|
||||
gcc_checking_assert (found || !a->merge (*n, false));
|
||||
if (found)
|
||||
{
|
||||
accesses->unordered_remove (i);
|
||||
if (index == accesses->length ())
|
||||
{
|
||||
index = i;
|
||||
i++;
|
||||
}
|
||||
if (restart)
|
||||
i = 0;
|
||||
}
|
||||
else
|
||||
i++;
|
||||
}
|
||||
else
|
||||
i++;
|
||||
}
|
||||
|
||||
/* Insert access with OFFSET and SIZE.
|
||||
Collapse tree if it has more than MAX_ACCESSES entries.
|
||||
If RECORD_ADJUSTMENTs is true avoid too many interval extensions.
|
||||
Return true if record was changed.
|
||||
|
||||
Reutrn 0 if nothing changed, 1 if insert was successful and -1
|
||||
if entries should be collapsed. */
|
||||
int
|
||||
modref_access_node::insert (vec <modref_access_node, va_gc> *&accesses,
|
||||
modref_access_node a, size_t max_accesses,
|
||||
bool record_adjustments)
|
||||
{
|
||||
size_t i, j;
|
||||
modref_access_node *a2;
|
||||
|
||||
/* Verify that list does not contain redundant accesses. */
|
||||
if (flag_checking)
|
||||
{
|
||||
size_t i, i2;
|
||||
modref_access_node *a, *a2;
|
||||
|
||||
FOR_EACH_VEC_SAFE_ELT (accesses, i, a)
|
||||
{
|
||||
FOR_EACH_VEC_SAFE_ELT (accesses, i2, a2)
|
||||
if (i != i2)
|
||||
gcc_assert (!a->contains (*a2));
|
||||
}
|
||||
}
|
||||
|
||||
FOR_EACH_VEC_SAFE_ELT (accesses, i, a2)
|
||||
{
|
||||
if (a2->contains (a))
|
||||
return 0;
|
||||
if (a.contains (*a2))
|
||||
{
|
||||
a.adjustments = 0;
|
||||
a2->parm_index = a.parm_index;
|
||||
a2->parm_offset_known = a.parm_offset_known;
|
||||
a2->update (a.parm_offset, a.offset, a.size, a.max_size,
|
||||
record_adjustments);
|
||||
modref_access_node::try_merge_with (accesses, i);
|
||||
return 1;
|
||||
}
|
||||
if (a2->merge (a, record_adjustments))
|
||||
{
|
||||
modref_access_node::try_merge_with (accesses, i);
|
||||
return 1;
|
||||
}
|
||||
gcc_checking_assert (!(a == *a2));
|
||||
}
|
||||
|
||||
/* If this base->ref pair has too many accesses stored, we will clear
|
||||
all accesses and bail out. */
|
||||
if (accesses && accesses->length () >= max_accesses)
|
||||
{
|
||||
if (max_accesses < 2)
|
||||
return -1;
|
||||
/* Find least harmful merge and perform it. */
|
||||
int best1 = -1, best2 = -1;
|
||||
FOR_EACH_VEC_SAFE_ELT (accesses, i, a2)
|
||||
{
|
||||
for (j = i + 1; j < accesses->length (); j++)
|
||||
if (best1 < 0
|
||||
|| modref_access_node::closer_pair_p
|
||||
(*a2, (*accesses)[j],
|
||||
(*accesses)[best1],
|
||||
best2 < 0 ? a : (*accesses)[best2]))
|
||||
{
|
||||
best1 = i;
|
||||
best2 = j;
|
||||
}
|
||||
if (modref_access_node::closer_pair_p
|
||||
(*a2, a,
|
||||
(*accesses)[best1],
|
||||
best2 < 0 ? a : (*accesses)[best2]))
|
||||
{
|
||||
best1 = i;
|
||||
best2 = -1;
|
||||
}
|
||||
}
|
||||
(*accesses)[best1].forced_merge (best2 < 0 ? a : (*accesses)[best2],
|
||||
record_adjustments);
|
||||
/* Check that merging indeed merged ranges. */
|
||||
gcc_checking_assert ((*accesses)[best1].contains
|
||||
(best2 < 0 ? a : (*accesses)[best2]));
|
||||
if (!(*accesses)[best1].useful_p ())
|
||||
return -1;
|
||||
if (dump_file && best2 >= 0)
|
||||
fprintf (dump_file,
|
||||
"--param param=modref-max-accesses limit reached;"
|
||||
" merging %i and %i\n", best1, best2);
|
||||
else if (dump_file)
|
||||
fprintf (dump_file,
|
||||
"--param param=modref-max-accesses limit reached;"
|
||||
" merging with %i\n", best1);
|
||||
modref_access_node::try_merge_with (accesses, best1);
|
||||
if (best2 >= 0)
|
||||
insert (accesses, a, max_accesses, record_adjustments);
|
||||
return 1;
|
||||
}
|
||||
a.adjustments = 0;
|
||||
vec_safe_push (accesses, a);
|
||||
return 1;
|
||||
}
|
||||
|
||||
namespace selftest {
|
||||
|
||||
static void
|
||||
|
|
|
|||
|
|
@ -57,7 +57,6 @@ enum modref_special_parms {
|
|||
/* Memory access. */
|
||||
struct GTY(()) modref_access_node
|
||||
{
|
||||
|
||||
/* Access range information (in bits). */
|
||||
poly_int64 offset;
|
||||
poly_int64 size;
|
||||
|
|
@ -88,380 +87,28 @@ struct GTY(()) modref_access_node
|
|||
|| known_ge (offset, 0));
|
||||
}
|
||||
/* Return true if both accesses are the same. */
|
||||
bool operator == (modref_access_node &a) const
|
||||
{
|
||||
if (parm_index != a.parm_index)
|
||||
return false;
|
||||
if (parm_index != MODREF_UNKNOWN_PARM)
|
||||
{
|
||||
if (parm_offset_known != a.parm_offset_known)
|
||||
return false;
|
||||
if (parm_offset_known
|
||||
&& !known_eq (parm_offset, a.parm_offset))
|
||||
return false;
|
||||
}
|
||||
if (range_info_useful_p () != a.range_info_useful_p ())
|
||||
return false;
|
||||
if (range_info_useful_p ()
|
||||
&& (!known_eq (a.offset, offset)
|
||||
|| !known_eq (a.size, size)
|
||||
|| !known_eq (a.max_size, max_size)))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
/* Return true A is a subaccess. */
|
||||
bool contains (const modref_access_node &a) const
|
||||
{
|
||||
poly_int64 aoffset_adj = 0;
|
||||
if (parm_index != MODREF_UNKNOWN_PARM)
|
||||
{
|
||||
if (parm_index != a.parm_index)
|
||||
return false;
|
||||
if (parm_offset_known)
|
||||
{
|
||||
if (!a.parm_offset_known)
|
||||
return false;
|
||||
/* Accesses are never below parm_offset, so look
|
||||
for smaller offset.
|
||||
If access ranges are known still allow merging
|
||||
when bit offsets comparsion passes. */
|
||||
if (!known_le (parm_offset, a.parm_offset)
|
||||
&& !range_info_useful_p ())
|
||||
return false;
|
||||
/* We allow negative aoffset_adj here in case
|
||||
there is an useful range. This is because adding
|
||||
a.offset may result in non-ngative offset again.
|
||||
Ubsan fails on val << LOG_BITS_PER_UNIT where val
|
||||
is negative. */
|
||||
aoffset_adj = (a.parm_offset - parm_offset)
|
||||
* BITS_PER_UNIT;
|
||||
}
|
||||
}
|
||||
if (range_info_useful_p ())
|
||||
{
|
||||
if (!a.range_info_useful_p ())
|
||||
return false;
|
||||
/* Sizes of stores are used to check that object is big enough
|
||||
to fit the store, so smaller or unknown sotre is more general
|
||||
than large store. */
|
||||
if (known_size_p (size)
|
||||
&& (!known_size_p (a.size)
|
||||
|| !known_le (size, a.size)))
|
||||
return false;
|
||||
if (known_size_p (max_size))
|
||||
return known_subrange_p (a.offset + aoffset_adj,
|
||||
a.max_size, offset, max_size);
|
||||
else
|
||||
return known_le (offset, a.offset + aoffset_adj);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
/* Update access range to new parameters.
|
||||
If RECORD_ADJUSTMENTS is true, record number of changes in the access
|
||||
and if threshold is exceeded start dropping precision
|
||||
so only constantly many updates are possible. This makes dataflow
|
||||
to converge. */
|
||||
void update (poly_int64 parm_offset1,
|
||||
poly_int64 offset1, poly_int64 size1, poly_int64 max_size1,
|
||||
bool record_adjustments)
|
||||
{
|
||||
if (known_eq (parm_offset, parm_offset1)
|
||||
&& known_eq (offset, offset1)
|
||||
&& known_eq (size, size1)
|
||||
&& known_eq (max_size, max_size1))
|
||||
return;
|
||||
if (!record_adjustments
|
||||
|| (++adjustments) < param_modref_max_adjustments)
|
||||
{
|
||||
parm_offset = parm_offset1;
|
||||
offset = offset1;
|
||||
size = size1;
|
||||
max_size = max_size1;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (dump_file)
|
||||
fprintf (dump_file,
|
||||
"--param param=modref-max-adjustments limit reached:");
|
||||
if (!known_eq (parm_offset, parm_offset1))
|
||||
{
|
||||
if (dump_file)
|
||||
fprintf (dump_file, " parm_offset cleared");
|
||||
parm_offset_known = false;
|
||||
}
|
||||
if (!known_eq (size, size1))
|
||||
{
|
||||
size = -1;
|
||||
if (dump_file)
|
||||
fprintf (dump_file, " size cleared");
|
||||
}
|
||||
if (!known_eq (max_size, max_size1))
|
||||
{
|
||||
max_size = -1;
|
||||
if (dump_file)
|
||||
fprintf (dump_file, " max_size cleared");
|
||||
}
|
||||
if (!known_eq (offset, offset1))
|
||||
{
|
||||
offset = 0;
|
||||
if (dump_file)
|
||||
fprintf (dump_file, " offset cleared");
|
||||
}
|
||||
if (dump_file)
|
||||
fprintf (dump_file, "\n");
|
||||
}
|
||||
}
|
||||
/* Merge in access A if it is possible to do without losing
|
||||
precision. Return true if successful.
|
||||
If RECORD_ADJUSTMENTs is true, remember how many interval
|
||||
was prolonged and punt when there are too many. */
|
||||
bool merge (const modref_access_node &a, bool record_adjustments)
|
||||
{
|
||||
poly_int64 offset1 = 0;
|
||||
poly_int64 aoffset1 = 0;
|
||||
poly_int64 new_parm_offset = 0;
|
||||
|
||||
/* We assume that containment was tested earlier. */
|
||||
gcc_checking_assert (!contains (a) && !a.contains (*this));
|
||||
if (parm_index != MODREF_UNKNOWN_PARM)
|
||||
{
|
||||
if (parm_index != a.parm_index)
|
||||
return false;
|
||||
if (parm_offset_known)
|
||||
{
|
||||
if (!a.parm_offset_known)
|
||||
return false;
|
||||
if (!combined_offsets (a, &new_parm_offset, &offset1, &aoffset1))
|
||||
return false;
|
||||
}
|
||||
}
|
||||
/* See if we can merge ranges. */
|
||||
if (range_info_useful_p ())
|
||||
{
|
||||
/* In this case we have containment that should be
|
||||
handled earlier. */
|
||||
gcc_checking_assert (a.range_info_useful_p ());
|
||||
|
||||
/* If a.size is less specified than size, merge only
|
||||
if intervals are otherwise equivalent. */
|
||||
if (known_size_p (size)
|
||||
&& (!known_size_p (a.size) || known_lt (a.size, size)))
|
||||
{
|
||||
if (((known_size_p (max_size) || known_size_p (a.max_size))
|
||||
&& !known_eq (max_size, a.max_size))
|
||||
|| !known_eq (offset1, aoffset1))
|
||||
return false;
|
||||
update (new_parm_offset, offset1, a.size, max_size,
|
||||
record_adjustments);
|
||||
return true;
|
||||
}
|
||||
/* If sizes are same, we can extend the interval. */
|
||||
if ((known_size_p (size) || known_size_p (a.size))
|
||||
&& !known_eq (size, a.size))
|
||||
return false;
|
||||
if (known_le (offset1, aoffset1))
|
||||
{
|
||||
if (!known_size_p (max_size)
|
||||
|| known_ge (offset1 + max_size, aoffset1))
|
||||
{
|
||||
update2 (new_parm_offset, offset1, size, max_size,
|
||||
aoffset1, a.size, a.max_size,
|
||||
record_adjustments);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
else if (known_le (aoffset1, offset1))
|
||||
{
|
||||
if (!known_size_p (a.max_size)
|
||||
|| known_ge (aoffset1 + a.max_size, offset1))
|
||||
{
|
||||
update2 (new_parm_offset, offset1, size, max_size,
|
||||
aoffset1, a.size, a.max_size,
|
||||
record_adjustments);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
update (new_parm_offset, offset1,
|
||||
size, max_size, record_adjustments);
|
||||
return true;
|
||||
}
|
||||
/* Return true if A1 and B1 can be merged with lower informatoin
|
||||
less than A2 and B2.
|
||||
Assume that no containment or lossless merging is possible. */
|
||||
static bool closer_pair_p (const modref_access_node &a1,
|
||||
const modref_access_node &b1,
|
||||
const modref_access_node &a2,
|
||||
const modref_access_node &b2)
|
||||
{
|
||||
/* Merging different parm indexes comes to complete loss
|
||||
of range info. */
|
||||
if (a1.parm_index != b1.parm_index)
|
||||
return false;
|
||||
if (a2.parm_index != b2.parm_index)
|
||||
return true;
|
||||
/* If parm is known and parm indexes are the same we should
|
||||
already have containment. */
|
||||
gcc_checking_assert (a1.parm_offset_known && b1.parm_offset_known);
|
||||
gcc_checking_assert (a2.parm_offset_known && b2.parm_offset_known);
|
||||
|
||||
/* First normalize offsets for parm offsets. */
|
||||
poly_int64 new_parm_offset, offseta1, offsetb1, offseta2, offsetb2;
|
||||
if (!a1.combined_offsets (b1, &new_parm_offset, &offseta1, &offsetb1)
|
||||
|| !a2.combined_offsets (b2, &new_parm_offset, &offseta2, &offsetb2))
|
||||
gcc_unreachable ();
|
||||
|
||||
|
||||
/* Now compute distnace of the intervals. */
|
||||
poly_int64 dist1, dist2;
|
||||
if (known_le (offseta1, offsetb1))
|
||||
{
|
||||
if (!known_size_p (a1.max_size))
|
||||
dist1 = 0;
|
||||
else
|
||||
dist1 = offsetb1 - offseta1 - a1.max_size;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!known_size_p (b1.max_size))
|
||||
dist1 = 0;
|
||||
else
|
||||
dist1 = offseta1 - offsetb1 - b1.max_size;
|
||||
}
|
||||
if (known_le (offseta2, offsetb2))
|
||||
{
|
||||
if (!known_size_p (a2.max_size))
|
||||
dist2 = 0;
|
||||
else
|
||||
dist2 = offsetb2 - offseta2 - a2.max_size;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!known_size_p (b2.max_size))
|
||||
dist2 = 0;
|
||||
else
|
||||
dist2 = offseta2 - offsetb2 - b2.max_size;
|
||||
}
|
||||
/* It may happen that intervals overlap in case size
|
||||
is different. Preffer the overlap to non-overlap. */
|
||||
if (known_lt (dist1, 0) && known_ge (dist2, 0))
|
||||
return true;
|
||||
if (known_lt (dist2, 0) && known_ge (dist1, 0))
|
||||
return false;
|
||||
if (known_lt (dist1, 0))
|
||||
/* If both overlaps minimize overlap. */
|
||||
return known_le (dist2, dist1);
|
||||
else
|
||||
/* If both are disjoint look for smaller distance. */
|
||||
return known_le (dist1, dist2);
|
||||
}
|
||||
|
||||
/* Merge in access A while losing precision. */
|
||||
void forced_merge (const modref_access_node &a, bool record_adjustments)
|
||||
{
|
||||
if (parm_index != a.parm_index)
|
||||
{
|
||||
gcc_checking_assert (parm_index != MODREF_UNKNOWN_PARM);
|
||||
parm_index = MODREF_UNKNOWN_PARM;
|
||||
return;
|
||||
}
|
||||
|
||||
/* We assume that containment and lossless merging
|
||||
was tested earlier. */
|
||||
gcc_checking_assert (!contains (a) && !a.contains (*this)
|
||||
&& !merge (a, record_adjustments));
|
||||
gcc_checking_assert (parm_offset_known && a.parm_offset_known);
|
||||
|
||||
poly_int64 new_parm_offset, offset1, aoffset1;
|
||||
if (!combined_offsets (a, &new_parm_offset, &offset1, &aoffset1))
|
||||
{
|
||||
parm_offset_known = false;
|
||||
return;
|
||||
}
|
||||
gcc_checking_assert (range_info_useful_p ()
|
||||
&& a.range_info_useful_p ());
|
||||
if (record_adjustments)
|
||||
adjustments += a.adjustments;
|
||||
update2 (new_parm_offset,
|
||||
offset1, size, max_size,
|
||||
aoffset1, a.size, a.max_size,
|
||||
record_adjustments);
|
||||
}
|
||||
bool operator == (modref_access_node &a) const;
|
||||
/* Insert A into ACCESSES. Limit size of vector to MAX_ACCESSES and if
|
||||
RECORD_ADJUSTMENT is true keep track of adjustment counts.
|
||||
Return 0 if nothing changed, 1 is insertion suceeded and -1 if
|
||||
failed. */
|
||||
static int insert (vec <modref_access_node, va_gc> *&accesses,
|
||||
modref_access_node a, size_t max_accesses,
|
||||
bool record_adjustments);
|
||||
private:
|
||||
/* Merge two ranges both starting at parm_offset1 and update THIS
|
||||
with result. */
|
||||
void update2 (poly_int64 parm_offset1,
|
||||
poly_int64 offset1, poly_int64 size1, poly_int64 max_size1,
|
||||
poly_int64 offset2, poly_int64 size2, poly_int64 max_size2,
|
||||
bool record_adjustments)
|
||||
{
|
||||
poly_int64 new_size = size1;
|
||||
|
||||
if (!known_size_p (size2)
|
||||
|| known_le (size2, size1))
|
||||
new_size = size2;
|
||||
else
|
||||
gcc_checking_assert (known_le (size1, size2));
|
||||
|
||||
if (known_le (offset1, offset2))
|
||||
;
|
||||
else if (known_le (offset2, offset1))
|
||||
{
|
||||
std::swap (offset1, offset2);
|
||||
std::swap (max_size1, max_size2);
|
||||
}
|
||||
else
|
||||
gcc_unreachable ();
|
||||
|
||||
poly_int64 new_max_size;
|
||||
|
||||
if (!known_size_p (max_size1))
|
||||
new_max_size = max_size1;
|
||||
else if (!known_size_p (max_size2))
|
||||
new_max_size = max_size2;
|
||||
else
|
||||
{
|
||||
new_max_size = max_size2 + offset2 - offset1;
|
||||
if (known_le (new_max_size, max_size1))
|
||||
new_max_size = max_size1;
|
||||
}
|
||||
|
||||
update (parm_offset1, offset1,
|
||||
new_size, new_max_size, record_adjustments);
|
||||
}
|
||||
/* Given access nodes THIS and A, return true if they
|
||||
can be done with common parm_offsets. In this case
|
||||
return parm offset in new_parm_offset, new_offset
|
||||
which is start of range in THIS and new_aoffset that
|
||||
is start of range in A. */
|
||||
bool combined_offsets (const modref_access_node &a,
|
||||
poly_int64 *new_parm_offset,
|
||||
poly_int64 *new_offset,
|
||||
poly_int64 *new_aoffset) const
|
||||
{
|
||||
gcc_checking_assert (parm_offset_known && a.parm_offset_known);
|
||||
if (known_le (a.parm_offset, parm_offset))
|
||||
{
|
||||
*new_offset = offset
|
||||
+ ((parm_offset - a.parm_offset)
|
||||
<< LOG2_BITS_PER_UNIT);
|
||||
*new_aoffset = a.offset;
|
||||
*new_parm_offset = a.parm_offset;
|
||||
return true;
|
||||
}
|
||||
else if (known_le (parm_offset, a.parm_offset))
|
||||
{
|
||||
*new_aoffset = a.offset
|
||||
+ ((a.parm_offset - parm_offset)
|
||||
<< LOG2_BITS_PER_UNIT);
|
||||
*new_offset = offset;
|
||||
*new_parm_offset = parm_offset;
|
||||
return true;
|
||||
}
|
||||
else
|
||||
return false;
|
||||
}
|
||||
bool contains (const modref_access_node &) const;
|
||||
void update (poly_int64, poly_int64, poly_int64, poly_int64, bool);
|
||||
bool merge (const modref_access_node &, bool);
|
||||
static bool closer_pair_p (const modref_access_node &,
|
||||
const modref_access_node &,
|
||||
const modref_access_node &,
|
||||
const modref_access_node &);
|
||||
void forced_merge (const modref_access_node &, bool);
|
||||
void update2 (poly_int64, poly_int64, poly_int64, poly_int64,
|
||||
poly_int64, poly_int64, poly_int64, bool);
|
||||
bool combined_offsets (const modref_access_node &,
|
||||
poly_int64 *, poly_int64 *, poly_int64 *) const;
|
||||
static void try_merge_with (vec <modref_access_node, va_gc> *&, size_t);
|
||||
};
|
||||
|
||||
/* Access node specifying no useful info. */
|
||||
|
|
@ -489,20 +136,6 @@ struct GTY((user)) modref_ref_node
|
|||
every_access = true;
|
||||
}
|
||||
|
||||
/* Verify that list does not contain redundant accesses. */
|
||||
void verify ()
|
||||
{
|
||||
size_t i, i2;
|
||||
modref_access_node *a, *a2;
|
||||
|
||||
FOR_EACH_VEC_SAFE_ELT (accesses, i, a)
|
||||
{
|
||||
FOR_EACH_VEC_SAFE_ELT (accesses, i2, a2)
|
||||
if (i != i2)
|
||||
gcc_assert (!a->contains (*a2));
|
||||
}
|
||||
}
|
||||
|
||||
/* Insert access with OFFSET and SIZE.
|
||||
Collapse tree if it has more than MAX_ACCESSES entries.
|
||||
If RECORD_ADJUSTMENTs is true avoid too many interval extensions.
|
||||
|
|
@ -514,18 +147,12 @@ struct GTY((user)) modref_ref_node
|
|||
if (every_access)
|
||||
return false;
|
||||
|
||||
/* Otherwise, insert a node for the ref of the access under the base. */
|
||||
size_t i, j;
|
||||
modref_access_node *a2;
|
||||
|
||||
/* Only the following kind of paramters needs to be tracked.
|
||||
We do not track return slots because they are seen as a direct store
|
||||
in the caller. */
|
||||
gcc_checking_assert (a.parm_index >= 0
|
||||
|| a.parm_index == MODREF_STATIC_CHAIN_PARM
|
||||
|| a.parm_index == MODREF_UNKNOWN_PARM);
|
||||
if (flag_checking)
|
||||
verify ();
|
||||
|
||||
if (!a.useful_p ())
|
||||
{
|
||||
|
|
@ -537,130 +164,17 @@ struct GTY((user)) modref_ref_node
|
|||
return false;
|
||||
}
|
||||
|
||||
FOR_EACH_VEC_SAFE_ELT (accesses, i, a2)
|
||||
int ret = modref_access_node::insert (accesses, a, max_accesses,
|
||||
record_adjustments);
|
||||
if (ret == -1)
|
||||
{
|
||||
if (a2->contains (a))
|
||||
return false;
|
||||
if (a.contains (*a2))
|
||||
{
|
||||
a.adjustments = 0;
|
||||
a2->parm_index = a.parm_index;
|
||||
a2->parm_offset_known = a.parm_offset_known;
|
||||
a2->update (a.parm_offset, a.offset, a.size, a.max_size,
|
||||
record_adjustments);
|
||||
try_merge_with (i);
|
||||
return true;
|
||||
}
|
||||
if (a2->merge (a, record_adjustments))
|
||||
{
|
||||
try_merge_with (i);
|
||||
return true;
|
||||
}
|
||||
gcc_checking_assert (!(a == *a2));
|
||||
}
|
||||
|
||||
/* If this base->ref pair has too many accesses stored, we will clear
|
||||
all accesses and bail out. */
|
||||
if (accesses && accesses->length () >= max_accesses)
|
||||
{
|
||||
if (max_accesses < 2)
|
||||
{
|
||||
collapse ();
|
||||
if (dump_file)
|
||||
fprintf (dump_file,
|
||||
"--param param=modref-max-accesses limit reached;"
|
||||
" collapsing\n");
|
||||
return true;
|
||||
}
|
||||
/* Find least harmful merge and perform it. */
|
||||
int best1 = -1, best2 = -1;
|
||||
FOR_EACH_VEC_SAFE_ELT (accesses, i, a2)
|
||||
{
|
||||
for (j = i + 1; j < accesses->length (); j++)
|
||||
if (best1 < 0
|
||||
|| modref_access_node::closer_pair_p
|
||||
(*a2, (*accesses)[j],
|
||||
(*accesses)[best1],
|
||||
best2 < 0 ? a : (*accesses)[best2]))
|
||||
{
|
||||
best1 = i;
|
||||
best2 = j;
|
||||
}
|
||||
if (modref_access_node::closer_pair_p
|
||||
(*a2, a,
|
||||
(*accesses)[best1],
|
||||
best2 < 0 ? a : (*accesses)[best2]))
|
||||
{
|
||||
best1 = i;
|
||||
best2 = -1;
|
||||
}
|
||||
}
|
||||
(*accesses)[best1].forced_merge (best2 < 0 ? a : (*accesses)[best2],
|
||||
record_adjustments);
|
||||
/* Check that merging indeed merged ranges. */
|
||||
gcc_checking_assert ((*accesses)[best1].contains
|
||||
(best2 < 0 ? a : (*accesses)[best2]));
|
||||
if (!(*accesses)[best1].useful_p ())
|
||||
{
|
||||
collapse ();
|
||||
if (dump_file)
|
||||
fprintf (dump_file,
|
||||
"--param param=modref-max-accesses limit reached;"
|
||||
" collapsing\n");
|
||||
return true;
|
||||
}
|
||||
if (dump_file && best2 >= 0)
|
||||
if (dump_file)
|
||||
fprintf (dump_file,
|
||||
"--param param=modref-max-accesses limit reached;"
|
||||
" merging %i and %i\n", best1, best2);
|
||||
else if (dump_file)
|
||||
fprintf (dump_file,
|
||||
"--param param=modref-max-accesses limit reached;"
|
||||
" merging with %i\n", best1);
|
||||
try_merge_with (best1);
|
||||
if (best2 >= 0)
|
||||
insert_access (a, max_accesses, record_adjustments);
|
||||
return 1;
|
||||
" collapsing\n");
|
||||
collapse ();
|
||||
}
|
||||
a.adjustments = 0;
|
||||
vec_safe_push (accesses, a);
|
||||
return true;
|
||||
}
|
||||
private:
|
||||
/* Try to optimize the access list after entry INDEX was modified. */
|
||||
void
|
||||
try_merge_with (size_t index)
|
||||
{
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < accesses->length ();)
|
||||
if (i != index)
|
||||
{
|
||||
bool found = false, restart = false;
|
||||
modref_access_node *a = &(*accesses)[i];
|
||||
modref_access_node *n = &(*accesses)[index];
|
||||
|
||||
if (n->contains (*a))
|
||||
found = true;
|
||||
if (!found && n->merge (*a, false))
|
||||
found = restart = true;
|
||||
gcc_checking_assert (found || !a->merge (*n, false));
|
||||
if (found)
|
||||
{
|
||||
accesses->unordered_remove (i);
|
||||
if (index == accesses->length ())
|
||||
{
|
||||
index = i;
|
||||
i++;
|
||||
}
|
||||
if (restart)
|
||||
i = 0;
|
||||
}
|
||||
else
|
||||
i++;
|
||||
}
|
||||
else
|
||||
i++;
|
||||
return ret != 0;
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue