767 lines
22 KiB
C++
767 lines
22 KiB
C++
/* Data structure for the modref pass.
|
|
Copyright (C) 2020-2023 Free Software Foundation, Inc.
|
|
Contributed by David Cepelik and Jan Hubicka
|
|
|
|
This file is part of GCC.
|
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
|
the terms of the GNU General Public License as published by the Free
|
|
Software Foundation; either version 3, or (at your option) any later
|
|
version.
|
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GCC; see the file COPYING3. If not see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
/* modref_tree represent a decision tree that can be used by alias analysis
|
|
oracle to determine whether given memory access can be affected by a function
|
|
call. For every function we collect two trees, one for loads and other
|
|
for stores. Tree consist of following levels:
|
|
|
|
1) Base: this level represent base alias set of the access and refers
|
|
to sons (ref nodes). Flag all_refs means that all possible references
|
|
are aliasing.
|
|
|
|
Because for LTO streaming we need to stream types rather than alias sets
|
|
modref_base_node is implemented as a template.
|
|
2) Ref: this level represent ref alias set and links to accesses unless
|
|
all_refs flag is set.
|
|
Again ref is an template to allow LTO streaming.
|
|
3) Access: this level represent info about individual accesses. Presently
|
|
we record whether access is through a dereference of a function parameter
|
|
and if so we record the access range.
|
|
*/
|
|
|
|
#ifndef GCC_MODREF_TREE_H
|
|
#define GCC_MODREF_TREE_H
|
|
|
|
struct ipa_modref_summary;
|
|
|
|
/* parm indexes greater than 0 are normal parms.
|
|
Some negative values have special meaning. */
|
|
enum modref_special_parms {
|
|
MODREF_UNKNOWN_PARM = -1,
|
|
MODREF_STATIC_CHAIN_PARM = -2,
|
|
MODREF_RETSLOT_PARM = -3,
|
|
/* Used for bases that points to memory that escapes from function. */
|
|
MODREF_GLOBAL_MEMORY_PARM = -4,
|
|
/* Used in modref_parm_map to take references which can be removed
|
|
from the summary during summary update since they now points to local
|
|
memory. */
|
|
MODREF_LOCAL_MEMORY_PARM = -5
|
|
};
|
|
|
|
/* Modref record accesses relative to function parameters.
|
|
This is entry for single access specifying its base and access range.
|
|
|
|
Accesses can be collected to boundedly sized arrays using
|
|
modref_access_node::insert. */
|
|
struct GTY(()) modref_access_node
|
|
{
|
|
/* Access range information (in bits). */
|
|
poly_int64 offset;
|
|
poly_int64 size;
|
|
poly_int64 max_size;
|
|
|
|
/* Offset from parameter pointer to the base of the access (in bytes). */
|
|
poly_int64 parm_offset;
|
|
|
|
/* Index of parameter which specifies the base of access. -1 if base is not
|
|
a function parameter. */
|
|
int parm_index;
|
|
bool parm_offset_known;
|
|
/* Number of times interval was extended during dataflow.
|
|
This has to be limited in order to keep dataflow finite. */
|
|
unsigned char adjustments;
|
|
|
|
/* Return true if access node holds some useful info. */
|
|
bool useful_p () const
|
|
{
|
|
return parm_index != MODREF_UNKNOWN_PARM;
|
|
}
|
|
/* Return true if access can be used to determine a kill. */
|
|
bool useful_for_kill_p () const
|
|
{
|
|
return parm_offset_known && parm_index != MODREF_UNKNOWN_PARM
|
|
&& parm_index != MODREF_GLOBAL_MEMORY_PARM
|
|
&& parm_index != MODREF_RETSLOT_PARM && known_size_p (size)
|
|
&& known_eq (max_size, size)
|
|
&& known_gt (size, 0);
|
|
}
|
|
/* Dump range to debug OUT. */
|
|
void dump (FILE *out);
|
|
/* Return true if both accesses are the same. */
|
|
bool operator == (modref_access_node &a) const;
|
|
/* Return true if range info is useful. */
|
|
bool range_info_useful_p () const;
|
|
/* Return tree corresponding to parameter of the range in STMT. */
|
|
tree get_call_arg (const gcall *stmt) const;
|
|
/* Build ao_ref corresponding to the access and return true if successful. */
|
|
bool get_ao_ref (const gcall *stmt, class ao_ref *ref) const;
|
|
/* Stream access to OB. */
|
|
void stream_out (struct output_block *ob) const;
|
|
/* Stream access in from IB. */
|
|
static modref_access_node stream_in (struct lto_input_block *ib);
|
|
/* Insert A into vector 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 succeeded 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);
|
|
/* Same as insert but for kills where we are conservative the other way
|
|
around: if information is lost, the kill is lost. */
|
|
static bool insert_kill (vec<modref_access_node> &kills,
|
|
modref_access_node &a, bool record_adjustments);
|
|
private:
|
|
bool contains (const modref_access_node &) const;
|
|
bool contains_for_kills (const modref_access_node &) const;
|
|
void update (poly_int64, poly_int64, poly_int64, poly_int64, bool);
|
|
bool update_for_kills (poly_int64, poly_int64, poly_int64,
|
|
poly_int64, poly_int64, bool);
|
|
bool merge (const modref_access_node &, bool);
|
|
bool merge_for_kills (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. */
|
|
const modref_access_node unspecified_modref_access_node
|
|
= {0, -1, -1, 0, MODREF_UNKNOWN_PARM, false, 0};
|
|
|
|
template <typename T>
|
|
struct GTY((user)) modref_ref_node
|
|
{
|
|
T ref;
|
|
bool every_access;
|
|
vec <modref_access_node, va_gc> *accesses;
|
|
|
|
modref_ref_node (T ref):
|
|
ref (ref),
|
|
every_access (false),
|
|
accesses (NULL)
|
|
{}
|
|
|
|
/* Collapse the tree. */
|
|
void collapse ()
|
|
{
|
|
vec_free (accesses);
|
|
accesses = NULL;
|
|
every_access = true;
|
|
}
|
|
|
|
/* 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. */
|
|
bool insert_access (modref_access_node a, size_t max_accesses,
|
|
bool record_adjustments)
|
|
{
|
|
/* If this base->ref pair has no access information, bail out. */
|
|
if (every_access)
|
|
return false;
|
|
|
|
/* Only the following kind of parameters 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_GLOBAL_MEMORY_PARM
|
|
|| a.parm_index == MODREF_UNKNOWN_PARM);
|
|
|
|
if (!a.useful_p ())
|
|
{
|
|
if (!every_access)
|
|
{
|
|
collapse ();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int ret = modref_access_node::insert (accesses, a, max_accesses,
|
|
record_adjustments);
|
|
if (ret == -1)
|
|
{
|
|
if (dump_file)
|
|
fprintf (dump_file,
|
|
"--param modref-max-accesses limit reached; collapsing\n");
|
|
collapse ();
|
|
}
|
|
return ret != 0;
|
|
}
|
|
};
|
|
|
|
/* Base of an access. */
|
|
template <typename T>
|
|
struct GTY((user)) modref_base_node
|
|
{
|
|
T base;
|
|
vec <modref_ref_node <T> *, va_gc> *refs;
|
|
bool every_ref;
|
|
|
|
modref_base_node (T base):
|
|
base (base),
|
|
refs (NULL),
|
|
every_ref (false) {}
|
|
|
|
/* Search REF; return NULL if failed. */
|
|
modref_ref_node <T> *search (T ref)
|
|
{
|
|
size_t i;
|
|
modref_ref_node <T> *n;
|
|
FOR_EACH_VEC_SAFE_ELT (refs, i, n)
|
|
if (n->ref == ref)
|
|
return n;
|
|
return NULL;
|
|
}
|
|
|
|
/* Insert REF; collapse tree if there are more than MAX_REFS.
|
|
Return inserted ref and if CHANGED is non-null set it to true if
|
|
something changed. */
|
|
modref_ref_node <T> *insert_ref (T ref, size_t max_refs,
|
|
bool *changed = NULL)
|
|
{
|
|
modref_ref_node <T> *ref_node;
|
|
|
|
/* If the node is collapsed, don't do anything. */
|
|
if (every_ref)
|
|
return NULL;
|
|
|
|
/* Otherwise, insert a node for the ref of the access under the base. */
|
|
ref_node = search (ref);
|
|
if (ref_node)
|
|
return ref_node;
|
|
|
|
/* We always allow inserting ref 0. For non-0 refs there is upper
|
|
limit on number of entries and if exceeded,
|
|
drop ref conservatively to 0. */
|
|
if (ref && refs && refs->length () >= max_refs)
|
|
{
|
|
if (dump_file)
|
|
fprintf (dump_file, "--param modref-max-refs limit reached;"
|
|
" using 0\n");
|
|
ref = 0;
|
|
ref_node = search (ref);
|
|
if (ref_node)
|
|
return ref_node;
|
|
}
|
|
|
|
if (changed)
|
|
*changed = true;
|
|
|
|
ref_node = new (ggc_alloc <modref_ref_node <T> > ())modref_ref_node <T>
|
|
(ref);
|
|
vec_safe_push (refs, ref_node);
|
|
return ref_node;
|
|
}
|
|
|
|
void collapse ()
|
|
{
|
|
size_t i;
|
|
modref_ref_node <T> *r;
|
|
|
|
if (refs)
|
|
{
|
|
FOR_EACH_VEC_SAFE_ELT (refs, i, r)
|
|
{
|
|
r->collapse ();
|
|
ggc_free (r);
|
|
}
|
|
vec_free (refs);
|
|
}
|
|
refs = NULL;
|
|
every_ref = true;
|
|
}
|
|
};
|
|
|
|
/* Map translating parameters across function call. */
|
|
|
|
struct modref_parm_map
|
|
{
|
|
/* Default constructor. */
|
|
modref_parm_map ()
|
|
: parm_index (MODREF_UNKNOWN_PARM), parm_offset_known (false), parm_offset ()
|
|
{}
|
|
|
|
/* Index of parameter we translate to.
|
|
Values from special_params enum are permitted too. */
|
|
int parm_index;
|
|
bool parm_offset_known;
|
|
poly_int64 parm_offset;
|
|
};
|
|
|
|
/* Access tree for a single function. */
|
|
template <typename T>
|
|
struct GTY((user)) modref_tree
|
|
{
|
|
vec <modref_base_node <T> *, va_gc> *bases;
|
|
bool every_base;
|
|
|
|
modref_tree ():
|
|
bases (NULL),
|
|
every_base (false) {}
|
|
|
|
/* Insert BASE; collapse tree if there are more than MAX_REFS.
|
|
Return inserted base and if CHANGED is non-null set it to true if
|
|
something changed.
|
|
If table gets full, try to insert REF instead. */
|
|
|
|
modref_base_node <T> *insert_base (T base, T ref,
|
|
unsigned int max_bases,
|
|
bool *changed = NULL)
|
|
{
|
|
modref_base_node <T> *base_node;
|
|
|
|
/* If the node is collapsed, don't do anything. */
|
|
if (every_base)
|
|
return NULL;
|
|
|
|
/* Otherwise, insert a node for the base of the access into the tree. */
|
|
base_node = search (base);
|
|
if (base_node)
|
|
return base_node;
|
|
|
|
/* We always allow inserting base 0. For non-0 base there is upper
|
|
limit on number of entries and if exceeded,
|
|
drop base conservatively to ref and if it still does not fit to 0. */
|
|
if (base && bases && bases->length () >= max_bases)
|
|
{
|
|
base_node = search (ref);
|
|
if (base_node)
|
|
{
|
|
if (dump_file)
|
|
fprintf (dump_file, "--param modref-max-bases"
|
|
" limit reached; using ref\n");
|
|
return base_node;
|
|
}
|
|
if (dump_file)
|
|
fprintf (dump_file, "--param modref-max-bases"
|
|
" limit reached; using 0\n");
|
|
base = 0;
|
|
base_node = search (base);
|
|
if (base_node)
|
|
return base_node;
|
|
}
|
|
|
|
if (changed)
|
|
*changed = true;
|
|
|
|
base_node = new (ggc_alloc <modref_base_node <T> > ())
|
|
modref_base_node <T> (base);
|
|
vec_safe_push (bases, base_node);
|
|
return base_node;
|
|
}
|
|
|
|
/* Insert memory access to the tree.
|
|
Return true if something changed. */
|
|
bool insert (unsigned int max_bases,
|
|
unsigned int max_refs,
|
|
unsigned int max_accesses,
|
|
T base, T ref, modref_access_node a,
|
|
bool record_adjustments)
|
|
{
|
|
if (every_base)
|
|
return false;
|
|
|
|
bool changed = false;
|
|
|
|
/* We may end up with max_size being less than size for accesses past the
|
|
end of array. Those are undefined and safe to ignore. */
|
|
if (a.range_info_useful_p ()
|
|
&& known_size_p (a.size) && known_size_p (a.max_size)
|
|
&& known_lt (a.max_size, a.size))
|
|
{
|
|
if (dump_file)
|
|
fprintf (dump_file,
|
|
" - Paradoxical range. Ignoring\n");
|
|
return false;
|
|
}
|
|
if (known_size_p (a.size)
|
|
&& known_eq (a.size, 0))
|
|
{
|
|
if (dump_file)
|
|
fprintf (dump_file,
|
|
" - Zero size. Ignoring\n");
|
|
return false;
|
|
}
|
|
if (known_size_p (a.max_size)
|
|
&& known_eq (a.max_size, 0))
|
|
{
|
|
if (dump_file)
|
|
fprintf (dump_file,
|
|
" - Zero max_size. Ignoring\n");
|
|
return false;
|
|
}
|
|
gcc_checking_assert (!known_size_p (a.max_size)
|
|
|| !known_le (a.max_size, 0));
|
|
|
|
/* No useful information tracked; collapse everything. */
|
|
if (!base && !ref && !a.useful_p ())
|
|
{
|
|
collapse ();
|
|
return true;
|
|
}
|
|
|
|
modref_base_node <T> *base_node
|
|
= insert_base (base, ref, max_bases, &changed);
|
|
base = base_node->base;
|
|
/* If table got full we may end up with useless base. */
|
|
if (!base && !ref && !a.useful_p ())
|
|
{
|
|
collapse ();
|
|
return true;
|
|
}
|
|
if (base_node->every_ref)
|
|
return changed;
|
|
gcc_checking_assert (search (base) != NULL);
|
|
|
|
/* No useful ref info tracked; collapse base. */
|
|
if (!ref && !a.useful_p ())
|
|
{
|
|
base_node->collapse ();
|
|
return true;
|
|
}
|
|
|
|
modref_ref_node <T> *ref_node
|
|
= base_node->insert_ref (ref, max_refs, &changed);
|
|
ref = ref_node->ref;
|
|
|
|
if (ref_node->every_access)
|
|
return changed;
|
|
changed |= ref_node->insert_access (a, max_accesses,
|
|
record_adjustments);
|
|
/* See if we failed to add useful access. */
|
|
if (ref_node->every_access)
|
|
{
|
|
/* Collapse everything if there is no useful base and ref. */
|
|
if (!base && !ref)
|
|
{
|
|
collapse ();
|
|
gcc_checking_assert (changed);
|
|
}
|
|
/* Collapse base if there is no useful ref. */
|
|
else if (!ref)
|
|
{
|
|
base_node->collapse ();
|
|
gcc_checking_assert (changed);
|
|
}
|
|
}
|
|
return changed;
|
|
}
|
|
|
|
/* Insert memory access to the tree.
|
|
Return true if something changed. */
|
|
bool insert (tree fndecl,
|
|
T base, T ref, const modref_access_node &a,
|
|
bool record_adjustments)
|
|
{
|
|
return insert (opt_for_fn (fndecl, param_modref_max_bases),
|
|
opt_for_fn (fndecl, param_modref_max_refs),
|
|
opt_for_fn (fndecl, param_modref_max_accesses),
|
|
base, ref, a, record_adjustments);
|
|
}
|
|
|
|
/* Remove tree branches that are not useful (i.e. they will always pass). */
|
|
|
|
void cleanup ()
|
|
{
|
|
size_t i, j;
|
|
modref_base_node <T> *base_node;
|
|
modref_ref_node <T> *ref_node;
|
|
|
|
if (!bases)
|
|
return;
|
|
|
|
for (i = 0; vec_safe_iterate (bases, i, &base_node);)
|
|
{
|
|
if (base_node->refs)
|
|
for (j = 0; vec_safe_iterate (base_node->refs, j, &ref_node);)
|
|
{
|
|
if (!ref_node->every_access
|
|
&& (!ref_node->accesses
|
|
|| !ref_node->accesses->length ()))
|
|
{
|
|
base_node->refs->unordered_remove (j);
|
|
vec_free (ref_node->accesses);
|
|
ggc_delete (ref_node);
|
|
}
|
|
else
|
|
j++;
|
|
}
|
|
if (!base_node->every_ref
|
|
&& (!base_node->refs || !base_node->refs->length ()))
|
|
{
|
|
bases->unordered_remove (i);
|
|
vec_free (base_node->refs);
|
|
ggc_delete (base_node);
|
|
}
|
|
else
|
|
i++;
|
|
}
|
|
if (bases && !bases->length ())
|
|
{
|
|
vec_free (bases);
|
|
bases = NULL;
|
|
}
|
|
}
|
|
|
|
/* Merge OTHER into the tree.
|
|
PARM_MAP, if non-NULL, maps parm indexes of callee to caller.
|
|
Similar CHAIN_MAP, if non-NULL, maps static chain of callee to caller.
|
|
Return true if something has changed. */
|
|
bool merge (unsigned int max_bases,
|
|
unsigned int max_refs,
|
|
unsigned int max_accesses,
|
|
modref_tree <T> *other, vec <modref_parm_map> *parm_map,
|
|
modref_parm_map *static_chain_map,
|
|
bool record_accesses,
|
|
bool promote_unknown_to_global = false)
|
|
{
|
|
if (!other || every_base)
|
|
return false;
|
|
if (other->every_base)
|
|
{
|
|
collapse ();
|
|
return true;
|
|
}
|
|
|
|
bool changed = false;
|
|
size_t i, j, k;
|
|
modref_base_node <T> *base_node, *my_base_node;
|
|
modref_ref_node <T> *ref_node;
|
|
modref_access_node *access_node;
|
|
bool release = false;
|
|
|
|
/* For self-recursive functions we may end up merging summary into itself;
|
|
produce copy first so we do not modify summary under our own hands. */
|
|
if (other == this)
|
|
{
|
|
release = true;
|
|
other = modref_tree<T>::create_ggc ();
|
|
other->copy_from (this);
|
|
}
|
|
|
|
FOR_EACH_VEC_SAFE_ELT (other->bases, i, base_node)
|
|
{
|
|
if (base_node->every_ref)
|
|
{
|
|
my_base_node = insert_base (base_node->base, 0,
|
|
max_bases, &changed);
|
|
if (my_base_node && !my_base_node->every_ref)
|
|
{
|
|
my_base_node->collapse ();
|
|
cleanup ();
|
|
changed = true;
|
|
}
|
|
}
|
|
else
|
|
FOR_EACH_VEC_SAFE_ELT (base_node->refs, j, ref_node)
|
|
{
|
|
if (ref_node->every_access)
|
|
{
|
|
changed |= insert (max_bases, max_refs, max_accesses,
|
|
base_node->base,
|
|
ref_node->ref,
|
|
unspecified_modref_access_node,
|
|
record_accesses);
|
|
}
|
|
else
|
|
FOR_EACH_VEC_SAFE_ELT (ref_node->accesses, k, access_node)
|
|
{
|
|
modref_access_node a = *access_node;
|
|
|
|
if (a.parm_index != MODREF_UNKNOWN_PARM
|
|
&& a.parm_index != MODREF_GLOBAL_MEMORY_PARM
|
|
&& parm_map)
|
|
{
|
|
if (a.parm_index >= (int)parm_map->length ())
|
|
a.parm_index = MODREF_UNKNOWN_PARM;
|
|
else
|
|
{
|
|
modref_parm_map &m
|
|
= a.parm_index == MODREF_STATIC_CHAIN_PARM
|
|
? *static_chain_map
|
|
: (*parm_map) [a.parm_index];
|
|
if (m.parm_index == MODREF_LOCAL_MEMORY_PARM)
|
|
continue;
|
|
a.parm_offset += m.parm_offset;
|
|
a.parm_offset_known &= m.parm_offset_known;
|
|
a.parm_index = m.parm_index;
|
|
}
|
|
}
|
|
if (a.parm_index == MODREF_UNKNOWN_PARM
|
|
&& promote_unknown_to_global)
|
|
a.parm_index = MODREF_GLOBAL_MEMORY_PARM;
|
|
changed |= insert (max_bases, max_refs, max_accesses,
|
|
base_node->base, ref_node->ref,
|
|
a, record_accesses);
|
|
}
|
|
}
|
|
}
|
|
if (release)
|
|
ggc_delete (other);
|
|
return changed;
|
|
}
|
|
|
|
/* Merge OTHER into the tree.
|
|
PARM_MAP, if non-NULL, maps parm indexes of callee to caller.
|
|
Similar CHAIN_MAP, if non-NULL, maps static chain of callee to caller.
|
|
Return true if something has changed. */
|
|
bool merge (tree fndecl,
|
|
modref_tree <T> *other, vec <modref_parm_map> *parm_map,
|
|
modref_parm_map *static_chain_map,
|
|
bool record_accesses,
|
|
bool promote_unknown_to_global = false)
|
|
{
|
|
return merge (opt_for_fn (fndecl, param_modref_max_bases),
|
|
opt_for_fn (fndecl, param_modref_max_refs),
|
|
opt_for_fn (fndecl, param_modref_max_accesses),
|
|
other, parm_map, static_chain_map, record_accesses,
|
|
promote_unknown_to_global);
|
|
}
|
|
|
|
/* Copy OTHER to THIS. */
|
|
void copy_from (modref_tree <T> *other)
|
|
{
|
|
merge (INT_MAX, INT_MAX, INT_MAX, other, NULL, NULL, false);
|
|
}
|
|
|
|
/* Search BASE in tree; return NULL if failed. */
|
|
modref_base_node <T> *search (T base)
|
|
{
|
|
size_t i;
|
|
modref_base_node <T> *n;
|
|
FOR_EACH_VEC_SAFE_ELT (bases, i, n)
|
|
if (n->base == base)
|
|
return n;
|
|
return NULL;
|
|
}
|
|
|
|
/* Return true if tree contains access to global memory. */
|
|
bool global_access_p ()
|
|
{
|
|
size_t i, j, k;
|
|
modref_base_node <T> *base_node;
|
|
modref_ref_node <T> *ref_node;
|
|
modref_access_node *access_node;
|
|
if (every_base)
|
|
return true;
|
|
FOR_EACH_VEC_SAFE_ELT (bases, i, base_node)
|
|
{
|
|
if (base_node->every_ref)
|
|
return true;
|
|
FOR_EACH_VEC_SAFE_ELT (base_node->refs, j, ref_node)
|
|
{
|
|
if (ref_node->every_access)
|
|
return true;
|
|
FOR_EACH_VEC_SAFE_ELT (ref_node->accesses, k, access_node)
|
|
if (access_node->parm_index == MODREF_UNKNOWN_PARM
|
|
|| access_node->parm_index == MODREF_GLOBAL_MEMORY_PARM)
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* Return ggc allocated instance. We explicitly call destructors via
|
|
ggc_delete and do not want finalizers to be registered and
|
|
called at the garbage collection time. */
|
|
static modref_tree<T> *create_ggc ()
|
|
{
|
|
return new (ggc_alloc_no_dtor<modref_tree<T>> ())
|
|
modref_tree<T> ();
|
|
}
|
|
|
|
/* Remove all records and mark tree to alias with everything. */
|
|
void collapse ()
|
|
{
|
|
size_t i;
|
|
modref_base_node <T> *n;
|
|
|
|
if (bases)
|
|
{
|
|
FOR_EACH_VEC_SAFE_ELT (bases, i, n)
|
|
{
|
|
n->collapse ();
|
|
ggc_free (n);
|
|
}
|
|
vec_free (bases);
|
|
}
|
|
bases = NULL;
|
|
every_base = true;
|
|
}
|
|
|
|
/* Release memory. */
|
|
~modref_tree ()
|
|
{
|
|
collapse ();
|
|
}
|
|
|
|
/* Update parameter indexes in TT according to MAP. */
|
|
void
|
|
remap_params (vec <int> *map)
|
|
{
|
|
size_t i;
|
|
modref_base_node <T> *base_node;
|
|
FOR_EACH_VEC_SAFE_ELT (bases, i, base_node)
|
|
{
|
|
size_t j;
|
|
modref_ref_node <T> *ref_node;
|
|
FOR_EACH_VEC_SAFE_ELT (base_node->refs, j, ref_node)
|
|
{
|
|
size_t k;
|
|
modref_access_node *access_node;
|
|
FOR_EACH_VEC_SAFE_ELT (ref_node->accesses, k, access_node)
|
|
if (access_node->parm_index >= 0)
|
|
{
|
|
if (access_node->parm_index < (int)map->length ())
|
|
access_node->parm_index = (*map)[access_node->parm_index];
|
|
else
|
|
access_node->parm_index = MODREF_UNKNOWN_PARM;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
void gt_ggc_mx (modref_tree <int>* const&);
|
|
void gt_ggc_mx (modref_tree <tree_node*>* const&);
|
|
void gt_pch_nx (modref_tree <int>* const&);
|
|
void gt_pch_nx (modref_tree <tree_node*>* const&);
|
|
void gt_pch_nx (modref_tree <int>* const&, gt_pointer_operator op, void *cookie);
|
|
void gt_pch_nx (modref_tree <tree_node*>* const&, gt_pointer_operator op,
|
|
void *cookie);
|
|
|
|
void gt_ggc_mx (modref_base_node <int>*);
|
|
void gt_ggc_mx (modref_base_node <tree_node*>* &);
|
|
void gt_pch_nx (modref_base_node <int>* const&);
|
|
void gt_pch_nx (modref_base_node <tree_node*>* const&);
|
|
void gt_pch_nx (modref_base_node <int>* const&, gt_pointer_operator op,
|
|
void *cookie);
|
|
void gt_pch_nx (modref_base_node <tree_node*>* const&, gt_pointer_operator op,
|
|
void *cookie);
|
|
|
|
void gt_ggc_mx (modref_ref_node <int>*);
|
|
void gt_ggc_mx (modref_ref_node <tree_node*>* &);
|
|
void gt_pch_nx (modref_ref_node <int>* const&);
|
|
void gt_pch_nx (modref_ref_node <tree_node*>* const&);
|
|
void gt_pch_nx (modref_ref_node <int>* const&, gt_pointer_operator op,
|
|
void *cookie);
|
|
void gt_pch_nx (modref_ref_node <tree_node*>* const&, gt_pointer_operator op,
|
|
void *cookie);
|
|
|
|
#endif
|