hashval_t
hash_type_name (tree t)
{
gcc_checking_assert (TYPE_MAIN_VARIANT (t) == t);
/* If not in LTO, all main variants are unique, so we can do
pointer hash. */
if (!in_lto_p)
return htab_hash_pointer (t);
/* Anonymous types are unique. */
if (type_in_anonymous_namespace_p (t))
return htab_hash_pointer (t);
/* For polymorphic types, we can simply hash the virtual table. */
if (TYPE_BINFO (t) && BINFO_VTABLE (TYPE_BINFO (t)))
{
tree v = BINFO_VTABLE (TYPE_BINFO (t));
hashval_t hash = 0;
if (TREE_CODE (v) == POINTER_PLUS_EXPR)
{
hash = TREE_INT_CST_LOW (TREE_OPERAND (v, 1));
v = TREE_OPERAND (TREE_OPERAND (v, 0), 0);
}
v = DECL_ASSEMBLER_NAME (v);
hash = iterative_hash_hashval_t (hash, htab_hash_pointer (v));
return hash;
}
/* Rest is not implemented yet. */
gcc_unreachable ();
}
static void
record_target_from_binfo (vec <cgraph_node *> &nodes,
tree binfo,
tree otr_type,
tree type_binfo,
HOST_WIDE_INT otr_token,
tree outer_type,
HOST_WIDE_INT offset,
pointer_set_t *inserted,
pointer_set_t *matched_vtables,
bool anonymous)
{
tree type = BINFO_TYPE (binfo);
int i;
tree base_binfo;
gcc_checking_assert (BINFO_VTABLE (type_binfo));
if (types_same_for_odr (type, outer_type))
{
tree inner_binfo = get_binfo_at_offset (type_binfo,
offset, otr_type);
/* For types in anonymous namespace first check if the respective vtable
is alive. If not, we know the type can't be called. */
if (!flag_ltrans && anonymous)
{
tree vtable = BINFO_VTABLE (inner_binfo);
struct varpool_node *vnode;
if (TREE_CODE (vtable) == POINTER_PLUS_EXPR)
vtable = TREE_OPERAND (TREE_OPERAND (vtable, 0), 0);
vnode = varpool_get_node (vtable);
if (!vnode || !vnode->definition)
return;
}
gcc_assert (inner_binfo);
if (!pointer_set_insert (matched_vtables, BINFO_VTABLE (inner_binfo)))
{
tree target = gimple_get_virt_method_for_binfo (otr_token, inner_binfo);
if (target)
maybe_record_node (nodes, target, inserted, NULL);
}
return;
}
/* Walk bases. */
for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
/* Walking bases that have no virtual method is pointless excercise. */
if (polymorphic_type_binfo_p (base_binfo))
record_target_from_binfo (nodes, base_binfo, otr_type,
/* In the case of single inheritance,
the virtual table is shared with
the outer type. */
BINFO_VTABLE (base_binfo) ? base_binfo : type_binfo,
otr_token, outer_type, offset, inserted,
matched_vtables, anonymous);
}
static void
write_ts_binfo_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
{
unsigned i;
tree t;
/* Note that the number of BINFO slots has already been emitted in
EXPR's header (see streamer_write_tree_header) because this length
is needed to build the empty BINFO node on the reader side. */
FOR_EACH_VEC_ELT (tree, BINFO_BASE_BINFOS (expr), i, t)
stream_write_tree (ob, t, ref_p);
stream_write_tree (ob, NULL_TREE, false);
stream_write_tree (ob, BINFO_OFFSET (expr), ref_p);
stream_write_tree (ob, BINFO_VTABLE (expr), ref_p);
stream_write_tree (ob, BINFO_VPTR_FIELD (expr), ref_p);
streamer_write_uhwi (ob, VEC_length (tree, BINFO_BASE_ACCESSES (expr)));
FOR_EACH_VEC_ELT (tree, BINFO_BASE_ACCESSES (expr), i, t)
stream_write_tree (ob, t, ref_p);
stream_write_tree (ob, BINFO_INHERITANCE_CHAIN (expr), ref_p);
stream_write_tree (ob, BINFO_SUBVTT_INDEX (expr), ref_p);
stream_write_tree (ob, BINFO_VPTR_INDEX (expr), ref_p);
}
static void
lto_input_ts_binfo_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
unsigned i;
tree t;
/* Note that the number of slots in EXPR was read in
streamer_alloc_tree when instantiating EXPR. However, the
vector is empty so we cannot rely on vec::length to know how many
elements to read. So, this list is emitted as a 0-terminated
list on the writer side. */
do
{
t = stream_read_tree (ib, data_in);
if (t)
BINFO_BASE_BINFOS (expr)->quick_push (t);
}
while (t);
BINFO_OFFSET (expr) = stream_read_tree (ib, data_in);
BINFO_VTABLE (expr) = stream_read_tree (ib, data_in);
BINFO_VPTR_FIELD (expr) = stream_read_tree (ib, data_in);
/* The vector of BINFO_BASE_ACCESSES is pre-allocated during
unpacking the bitfield section. */
for (i = 0; i < vec_safe_length (BINFO_BASE_ACCESSES (expr)); i++)
{
tree a = stream_read_tree (ib, data_in);
(*BINFO_BASE_ACCESSES (expr))[i] = a;
}
/* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
and BINFO_VPTR_INDEX; these are used by C++ FE only. */
}
static void
write_ts_binfo_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
{
unsigned i;
tree t;
/* Note that the number of BINFO slots has already been emitted in
EXPR's header (see streamer_write_tree_header) because this length
is needed to build the empty BINFO node on the reader side. */
FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr), i, t)
stream_write_tree (ob, t, ref_p);
stream_write_tree (ob, NULL_TREE, false);
stream_write_tree (ob, BINFO_OFFSET (expr), ref_p);
stream_write_tree (ob, BINFO_VTABLE (expr), ref_p);
stream_write_tree (ob, BINFO_VPTR_FIELD (expr), ref_p);
/* The number of BINFO_BASE_ACCESSES has already been emitted in
EXPR's bitfield section. */
FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (expr), i, t)
stream_write_tree (ob, t, ref_p);
/* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
and BINFO_VPTR_INDEX; these are used by C++ FE only. */
}
static void
lto_input_ts_binfo_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
unsigned i, len;
tree t;
/* Note that the number of slots in EXPR was read in
streamer_alloc_tree when instantiating EXPR. However, the
vector is empty so we cannot rely on VEC_length to know how many
elements to read. So, this list is emitted as a 0-terminated
list on the writer side. */
do
{
t = stream_read_tree (ib, data_in);
if (t)
VEC_quick_push (tree, BINFO_BASE_BINFOS (expr), t);
}
while (t);
BINFO_OFFSET (expr) = stream_read_tree (ib, data_in);
BINFO_VTABLE (expr) = stream_read_tree (ib, data_in);
BINFO_VPTR_FIELD (expr) = stream_read_tree (ib, data_in);
len = streamer_read_uhwi (ib);
if (len > 0)
{
VEC_reserve_exact (tree, gc, BINFO_BASE_ACCESSES (expr), len);
for (i = 0; i < len; i++)
{
tree a = stream_read_tree (ib, data_in);
VEC_quick_push (tree, BINFO_BASE_ACCESSES (expr), a);
}
}
BINFO_INHERITANCE_CHAIN (expr) = stream_read_tree (ib, data_in);
BINFO_SUBVTT_INDEX (expr) = stream_read_tree (ib, data_in);
BINFO_VPTR_INDEX (expr) = stream_read_tree (ib, data_in);
}
static void
add_type_duplicate (odr_type val, tree type)
{
if (!val->types_set)
val->types_set = pointer_set_create ();
/* See if this duplicate is new. */
if (!pointer_set_insert (val->types_set, type))
{
bool merge = true;
bool base_mismatch = false;
gcc_assert (in_lto_p);
vec_safe_push (val->types, type);
unsigned int i,j;
/* First we compare memory layout. */
if (!types_compatible_p (val->type, type))
{
merge = false;
if (BINFO_VTABLE (TYPE_BINFO (val->type))
&& warning_at (DECL_SOURCE_LOCATION (TYPE_NAME (type)), 0,
"type %qD violates one definition rule ",
type))
inform (DECL_SOURCE_LOCATION (TYPE_NAME (val->type)),
"a type with the same name but different layout is "
"defined in another translation unit");
if (cgraph_dump_file)
{
fprintf (cgraph_dump_file, "ODR violation or merging or ODR type bug?\n");
print_node (cgraph_dump_file, "", val->type, 0);
putc ('\n',cgraph_dump_file);
print_node (cgraph_dump_file, "", type, 0);
putc ('\n',cgraph_dump_file);
}
}
/* Next sanity check that bases are the same. If not, we will end
up producing wrong answers. */
for (j = 0, i = 0; i < BINFO_N_BASE_BINFOS (TYPE_BINFO (type)); i++)
if (polymorphic_type_binfo_p (BINFO_BASE_BINFO (TYPE_BINFO (type), i)))
{
odr_type base = get_odr_type
(BINFO_TYPE
(BINFO_BASE_BINFO (TYPE_BINFO (type),
i)),
true);
if (val->bases.length () <= j || val->bases[j] != base)
base_mismatch = true;
j++;
}
if (base_mismatch)
{
merge = false;
if (warning_at (DECL_SOURCE_LOCATION (TYPE_NAME (type)), 0,
"type %qD violates one definition rule ",
type))
inform (DECL_SOURCE_LOCATION (TYPE_NAME (val->type)),
"a type with the same name but different bases is "
"defined in another translation unit");
if (cgraph_dump_file)
{
fprintf (cgraph_dump_file, "ODR bse violation or merging bug?\n");
print_node (cgraph_dump_file, "", val->type, 0);
putc ('\n',cgraph_dump_file);
print_node (cgraph_dump_file, "", type, 0);
putc ('\n',cgraph_dump_file);
}
}
/* Regularize things a little. During LTO same types may come with
different BINFOs. Either because their virtual table was
not merged by tree merging and only later at decl merging or
because one type comes with external vtable, while other
with internal. We want to merge equivalent binfos to conserve
memory and streaming overhead.
The external vtables are more harmful: they contain references
to external declarations of methods that may be defined in the
merged LTO unit. For this reason we absolutely need to remove
them and replace by internal variants. Not doing so will lead
to incomplete answers from possible_polymorphic_call_targets. */
if (!flag_ltrans && merge)
{
tree master_binfo = TYPE_BINFO (val->type);
tree v1 = BINFO_VTABLE (master_binfo);
tree v2 = BINFO_VTABLE (TYPE_BINFO (type));
if (TREE_CODE (v1) == POINTER_PLUS_EXPR)
{
gcc_assert (TREE_CODE (v2) == POINTER_PLUS_EXPR
&& operand_equal_p (TREE_OPERAND (v1, 1),
TREE_OPERAND (v2, 1), 0));
v1 = TREE_OPERAND (TREE_OPERAND (v1, 0), 0);
v2 = TREE_OPERAND (TREE_OPERAND (v2, 0), 0);
}
gcc_assert (DECL_ASSEMBLER_NAME (v1)
== DECL_ASSEMBLER_NAME (v2));
if (DECL_EXTERNAL (v1) && !DECL_EXTERNAL (v2))
{
unsigned int i;
TYPE_BINFO (val->type) = TYPE_BINFO (type);
for (i = 0; i < val->types->length (); i++)
{
if (TYPE_BINFO ((*val->types)[i])
== master_binfo)
TYPE_BINFO ((*val->types)[i]) = TYPE_BINFO (type);
}
}
else
TYPE_BINFO (type) = master_binfo;
}
}
}
static inline bool
polymorphic_type_binfo_p (tree binfo)
{
/* See if BINFO's type has an virtual table associtated with it. */
return BINFO_VTABLE (TYPE_BINFO (BINFO_TYPE (binfo)));
}