mirror of
https://git.FreeBSD.org/src.git
synced 2024-12-05 09:14:03 +00:00
2599 lines
73 KiB
C
2599 lines
73 KiB
C
/* Breadth-first and depth-first routines for
|
||
searching multiple-inheritance lattice for GNU C++.
|
||
Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
|
||
1999, 2000, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
|
||
Contributed by Michael Tiemann (tiemann@cygnus.com)
|
||
|
||
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 2, 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 COPYING. If not, write to
|
||
the Free Software Foundation, 51 Franklin Street, Fifth Floor,
|
||
Boston, MA 02110-1301, USA. */
|
||
|
||
/* High-level class interface. */
|
||
|
||
#include "config.h"
|
||
#include "system.h"
|
||
#include "coretypes.h"
|
||
#include "tm.h"
|
||
#include "tree.h"
|
||
#include "cp-tree.h"
|
||
#include "obstack.h"
|
||
#include "flags.h"
|
||
#include "rtl.h"
|
||
#include "output.h"
|
||
#include "toplev.h"
|
||
|
||
static int is_subobject_of_p (tree, tree);
|
||
static tree dfs_lookup_base (tree, void *);
|
||
static tree dfs_dcast_hint_pre (tree, void *);
|
||
static tree dfs_dcast_hint_post (tree, void *);
|
||
static tree dfs_debug_mark (tree, void *);
|
||
static tree dfs_walk_once_r (tree, tree (*pre_fn) (tree, void *),
|
||
tree (*post_fn) (tree, void *), void *data);
|
||
static void dfs_unmark_r (tree);
|
||
static int check_hidden_convs (tree, int, int, tree, tree, tree);
|
||
static tree split_conversions (tree, tree, tree, tree);
|
||
static int lookup_conversions_r (tree, int, int,
|
||
tree, tree, tree, tree, tree *, tree *);
|
||
static int look_for_overrides_r (tree, tree);
|
||
static tree lookup_field_r (tree, void *);
|
||
static tree dfs_accessible_post (tree, void *);
|
||
static tree dfs_walk_once_accessible_r (tree, bool, bool,
|
||
tree (*pre_fn) (tree, void *),
|
||
tree (*post_fn) (tree, void *),
|
||
void *data);
|
||
static tree dfs_walk_once_accessible (tree, bool,
|
||
tree (*pre_fn) (tree, void *),
|
||
tree (*post_fn) (tree, void *),
|
||
void *data);
|
||
static tree dfs_access_in_type (tree, void *);
|
||
static access_kind access_in_type (tree, tree);
|
||
static int protected_accessible_p (tree, tree, tree);
|
||
static int friend_accessible_p (tree, tree, tree);
|
||
static int template_self_reference_p (tree, tree);
|
||
static tree dfs_get_pure_virtuals (tree, void *);
|
||
|
||
|
||
/* Variables for gathering statistics. */
|
||
#ifdef GATHER_STATISTICS
|
||
static int n_fields_searched;
|
||
static int n_calls_lookup_field, n_calls_lookup_field_1;
|
||
static int n_calls_lookup_fnfields, n_calls_lookup_fnfields_1;
|
||
static int n_calls_get_base_type;
|
||
static int n_outer_fields_searched;
|
||
static int n_contexts_saved;
|
||
#endif /* GATHER_STATISTICS */
|
||
|
||
|
||
/* Data for lookup_base and its workers. */
|
||
|
||
struct lookup_base_data_s
|
||
{
|
||
tree t; /* type being searched. */
|
||
tree base; /* The base type we're looking for. */
|
||
tree binfo; /* Found binfo. */
|
||
bool via_virtual; /* Found via a virtual path. */
|
||
bool ambiguous; /* Found multiply ambiguous */
|
||
bool repeated_base; /* Whether there are repeated bases in the
|
||
hierarchy. */
|
||
bool want_any; /* Whether we want any matching binfo. */
|
||
};
|
||
|
||
/* Worker function for lookup_base. See if we've found the desired
|
||
base and update DATA_ (a pointer to LOOKUP_BASE_DATA_S). */
|
||
|
||
static tree
|
||
dfs_lookup_base (tree binfo, void *data_)
|
||
{
|
||
struct lookup_base_data_s *data = (struct lookup_base_data_s *) data_;
|
||
|
||
if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->base))
|
||
{
|
||
if (!data->binfo)
|
||
{
|
||
data->binfo = binfo;
|
||
data->via_virtual
|
||
= binfo_via_virtual (data->binfo, data->t) != NULL_TREE;
|
||
|
||
if (!data->repeated_base)
|
||
/* If there are no repeated bases, we can stop now. */
|
||
return binfo;
|
||
|
||
if (data->want_any && !data->via_virtual)
|
||
/* If this is a non-virtual base, then we can't do
|
||
better. */
|
||
return binfo;
|
||
|
||
return dfs_skip_bases;
|
||
}
|
||
else
|
||
{
|
||
gcc_assert (binfo != data->binfo);
|
||
|
||
/* We've found more than one matching binfo. */
|
||
if (!data->want_any)
|
||
{
|
||
/* This is immediately ambiguous. */
|
||
data->binfo = NULL_TREE;
|
||
data->ambiguous = true;
|
||
return error_mark_node;
|
||
}
|
||
|
||
/* Prefer one via a non-virtual path. */
|
||
if (!binfo_via_virtual (binfo, data->t))
|
||
{
|
||
data->binfo = binfo;
|
||
data->via_virtual = false;
|
||
return binfo;
|
||
}
|
||
|
||
/* There must be repeated bases, otherwise we'd have stopped
|
||
on the first base we found. */
|
||
return dfs_skip_bases;
|
||
}
|
||
}
|
||
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* Returns true if type BASE is accessible in T. (BASE is known to be
|
||
a (possibly non-proper) base class of T.) If CONSIDER_LOCAL_P is
|
||
true, consider any special access of the current scope, or access
|
||
bestowed by friendship. */
|
||
|
||
bool
|
||
accessible_base_p (tree t, tree base, bool consider_local_p)
|
||
{
|
||
tree decl;
|
||
|
||
/* [class.access.base]
|
||
|
||
A base class is said to be accessible if an invented public
|
||
member of the base class is accessible.
|
||
|
||
If BASE is a non-proper base, this condition is trivially
|
||
true. */
|
||
if (same_type_p (t, base))
|
||
return true;
|
||
/* Rather than inventing a public member, we use the implicit
|
||
public typedef created in the scope of every class. */
|
||
decl = TYPE_FIELDS (base);
|
||
while (!DECL_SELF_REFERENCE_P (decl))
|
||
decl = TREE_CHAIN (decl);
|
||
while (ANON_AGGR_TYPE_P (t))
|
||
t = TYPE_CONTEXT (t);
|
||
return accessible_p (t, decl, consider_local_p);
|
||
}
|
||
|
||
/* Lookup BASE in the hierarchy dominated by T. Do access checking as
|
||
ACCESS specifies. Return the binfo we discover. If KIND_PTR is
|
||
non-NULL, fill with information about what kind of base we
|
||
discovered.
|
||
|
||
If the base is inaccessible, or ambiguous, and the ba_quiet bit is
|
||
not set in ACCESS, then an error is issued and error_mark_node is
|
||
returned. If the ba_quiet bit is set, then no error is issued and
|
||
NULL_TREE is returned. */
|
||
|
||
tree
|
||
lookup_base (tree t, tree base, base_access access, base_kind *kind_ptr)
|
||
{
|
||
tree binfo;
|
||
tree t_binfo;
|
||
base_kind bk;
|
||
|
||
if (t == error_mark_node || base == error_mark_node)
|
||
{
|
||
if (kind_ptr)
|
||
*kind_ptr = bk_not_base;
|
||
return error_mark_node;
|
||
}
|
||
gcc_assert (TYPE_P (base));
|
||
|
||
if (!TYPE_P (t))
|
||
{
|
||
t_binfo = t;
|
||
t = BINFO_TYPE (t);
|
||
}
|
||
else
|
||
{
|
||
t = complete_type (TYPE_MAIN_VARIANT (t));
|
||
t_binfo = TYPE_BINFO (t);
|
||
}
|
||
|
||
base = complete_type (TYPE_MAIN_VARIANT (base));
|
||
|
||
if (t_binfo)
|
||
{
|
||
struct lookup_base_data_s data;
|
||
|
||
data.t = t;
|
||
data.base = base;
|
||
data.binfo = NULL_TREE;
|
||
data.ambiguous = data.via_virtual = false;
|
||
data.repeated_base = CLASSTYPE_REPEATED_BASE_P (t);
|
||
data.want_any = access == ba_any;
|
||
|
||
dfs_walk_once (t_binfo, dfs_lookup_base, NULL, &data);
|
||
binfo = data.binfo;
|
||
|
||
if (!binfo)
|
||
bk = data.ambiguous ? bk_ambig : bk_not_base;
|
||
else if (binfo == t_binfo)
|
||
bk = bk_same_type;
|
||
else if (data.via_virtual)
|
||
bk = bk_via_virtual;
|
||
else
|
||
bk = bk_proper_base;
|
||
}
|
||
else
|
||
{
|
||
binfo = NULL_TREE;
|
||
bk = bk_not_base;
|
||
}
|
||
|
||
/* Check that the base is unambiguous and accessible. */
|
||
if (access != ba_any)
|
||
switch (bk)
|
||
{
|
||
case bk_not_base:
|
||
break;
|
||
|
||
case bk_ambig:
|
||
if (!(access & ba_quiet))
|
||
{
|
||
error ("%qT is an ambiguous base of %qT", base, t);
|
||
binfo = error_mark_node;
|
||
}
|
||
break;
|
||
|
||
default:
|
||
if ((access & ba_check_bit)
|
||
/* If BASE is incomplete, then BASE and TYPE are probably
|
||
the same, in which case BASE is accessible. If they
|
||
are not the same, then TYPE is invalid. In that case,
|
||
there's no need to issue another error here, and
|
||
there's no implicit typedef to use in the code that
|
||
follows, so we skip the check. */
|
||
&& COMPLETE_TYPE_P (base)
|
||
&& !accessible_base_p (t, base, !(access & ba_ignore_scope)))
|
||
{
|
||
if (!(access & ba_quiet))
|
||
{
|
||
error ("%qT is an inaccessible base of %qT", base, t);
|
||
binfo = error_mark_node;
|
||
}
|
||
else
|
||
binfo = NULL_TREE;
|
||
bk = bk_inaccessible;
|
||
}
|
||
break;
|
||
}
|
||
|
||
if (kind_ptr)
|
||
*kind_ptr = bk;
|
||
|
||
return binfo;
|
||
}
|
||
|
||
/* Data for dcast_base_hint walker. */
|
||
|
||
struct dcast_data_s
|
||
{
|
||
tree subtype; /* The base type we're looking for. */
|
||
int virt_depth; /* Number of virtual bases encountered from most
|
||
derived. */
|
||
tree offset; /* Best hint offset discovered so far. */
|
||
bool repeated_base; /* Whether there are repeated bases in the
|
||
hierarchy. */
|
||
};
|
||
|
||
/* Worker for dcast_base_hint. Search for the base type being cast
|
||
from. */
|
||
|
||
static tree
|
||
dfs_dcast_hint_pre (tree binfo, void *data_)
|
||
{
|
||
struct dcast_data_s *data = (struct dcast_data_s *) data_;
|
||
|
||
if (BINFO_VIRTUAL_P (binfo))
|
||
data->virt_depth++;
|
||
|
||
if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->subtype))
|
||
{
|
||
if (data->virt_depth)
|
||
{
|
||
data->offset = ssize_int (-1);
|
||
return data->offset;
|
||
}
|
||
if (data->offset)
|
||
data->offset = ssize_int (-3);
|
||
else
|
||
data->offset = BINFO_OFFSET (binfo);
|
||
|
||
return data->repeated_base ? dfs_skip_bases : data->offset;
|
||
}
|
||
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* Worker for dcast_base_hint. Track the virtual depth. */
|
||
|
||
static tree
|
||
dfs_dcast_hint_post (tree binfo, void *data_)
|
||
{
|
||
struct dcast_data_s *data = (struct dcast_data_s *) data_;
|
||
|
||
if (BINFO_VIRTUAL_P (binfo))
|
||
data->virt_depth--;
|
||
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* The dynamic cast runtime needs a hint about how the static SUBTYPE type
|
||
started from is related to the required TARGET type, in order to optimize
|
||
the inheritance graph search. This information is independent of the
|
||
current context, and ignores private paths, hence get_base_distance is
|
||
inappropriate. Return a TREE specifying the base offset, BOFF.
|
||
BOFF >= 0, there is only one public non-virtual SUBTYPE base at offset BOFF,
|
||
and there are no public virtual SUBTYPE bases.
|
||
BOFF == -1, SUBTYPE occurs as multiple public virtual or non-virtual bases.
|
||
BOFF == -2, SUBTYPE is not a public base.
|
||
BOFF == -3, SUBTYPE occurs as multiple public non-virtual bases. */
|
||
|
||
tree
|
||
dcast_base_hint (tree subtype, tree target)
|
||
{
|
||
struct dcast_data_s data;
|
||
|
||
data.subtype = subtype;
|
||
data.virt_depth = 0;
|
||
data.offset = NULL_TREE;
|
||
data.repeated_base = CLASSTYPE_REPEATED_BASE_P (target);
|
||
|
||
dfs_walk_once_accessible (TYPE_BINFO (target), /*friends=*/false,
|
||
dfs_dcast_hint_pre, dfs_dcast_hint_post, &data);
|
||
return data.offset ? data.offset : ssize_int (-2);
|
||
}
|
||
|
||
/* Search for a member with name NAME in a multiple inheritance
|
||
lattice specified by TYPE. If it does not exist, return NULL_TREE.
|
||
If the member is ambiguously referenced, return `error_mark_node'.
|
||
Otherwise, return a DECL with the indicated name. If WANT_TYPE is
|
||
true, type declarations are preferred. */
|
||
|
||
/* Do a 1-level search for NAME as a member of TYPE. The caller must
|
||
figure out whether it can access this field. (Since it is only one
|
||
level, this is reasonable.) */
|
||
|
||
tree
|
||
lookup_field_1 (tree type, tree name, bool want_type)
|
||
{
|
||
tree field;
|
||
|
||
if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
|
||
|| TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
|
||
|| TREE_CODE (type) == TYPENAME_TYPE)
|
||
/* The TYPE_FIELDS of a TEMPLATE_TYPE_PARM and
|
||
BOUND_TEMPLATE_TEMPLATE_PARM are not fields at all;
|
||
instead TYPE_FIELDS is the TEMPLATE_PARM_INDEX. (Miraculously,
|
||
the code often worked even when we treated the index as a list
|
||
of fields!)
|
||
The TYPE_FIELDS of TYPENAME_TYPE is its TYPENAME_TYPE_FULLNAME. */
|
||
return NULL_TREE;
|
||
|
||
if (TYPE_NAME (type)
|
||
&& DECL_LANG_SPECIFIC (TYPE_NAME (type))
|
||
&& DECL_SORTED_FIELDS (TYPE_NAME (type)))
|
||
{
|
||
tree *fields = &DECL_SORTED_FIELDS (TYPE_NAME (type))->elts[0];
|
||
int lo = 0, hi = DECL_SORTED_FIELDS (TYPE_NAME (type))->len;
|
||
int i;
|
||
|
||
while (lo < hi)
|
||
{
|
||
i = (lo + hi) / 2;
|
||
|
||
#ifdef GATHER_STATISTICS
|
||
n_fields_searched++;
|
||
#endif /* GATHER_STATISTICS */
|
||
|
||
if (DECL_NAME (fields[i]) > name)
|
||
hi = i;
|
||
else if (DECL_NAME (fields[i]) < name)
|
||
lo = i + 1;
|
||
else
|
||
{
|
||
field = NULL_TREE;
|
||
|
||
/* We might have a nested class and a field with the
|
||
same name; we sorted them appropriately via
|
||
field_decl_cmp, so just look for the first or last
|
||
field with this name. */
|
||
if (want_type)
|
||
{
|
||
do
|
||
field = fields[i--];
|
||
while (i >= lo && DECL_NAME (fields[i]) == name);
|
||
if (TREE_CODE (field) != TYPE_DECL
|
||
&& !DECL_CLASS_TEMPLATE_P (field))
|
||
field = NULL_TREE;
|
||
}
|
||
else
|
||
{
|
||
do
|
||
field = fields[i++];
|
||
while (i < hi && DECL_NAME (fields[i]) == name);
|
||
}
|
||
return field;
|
||
}
|
||
}
|
||
return NULL_TREE;
|
||
}
|
||
|
||
field = TYPE_FIELDS (type);
|
||
|
||
#ifdef GATHER_STATISTICS
|
||
n_calls_lookup_field_1++;
|
||
#endif /* GATHER_STATISTICS */
|
||
for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
|
||
{
|
||
#ifdef GATHER_STATISTICS
|
||
n_fields_searched++;
|
||
#endif /* GATHER_STATISTICS */
|
||
gcc_assert (DECL_P (field));
|
||
if (DECL_NAME (field) == NULL_TREE
|
||
&& ANON_AGGR_TYPE_P (TREE_TYPE (field)))
|
||
{
|
||
tree temp = lookup_field_1 (TREE_TYPE (field), name, want_type);
|
||
if (temp)
|
||
return temp;
|
||
}
|
||
if (TREE_CODE (field) == USING_DECL)
|
||
{
|
||
/* We generally treat class-scope using-declarations as
|
||
ARM-style access specifications, because support for the
|
||
ISO semantics has not been implemented. So, in general,
|
||
there's no reason to return a USING_DECL, and the rest of
|
||
the compiler cannot handle that. Once the class is
|
||
defined, USING_DECLs are purged from TYPE_FIELDS; see
|
||
handle_using_decl. However, we make special efforts to
|
||
make using-declarations in class templates and class
|
||
template partial specializations work correctly. */
|
||
if (!DECL_DEPENDENT_P (field))
|
||
continue;
|
||
}
|
||
|
||
if (DECL_NAME (field) == name
|
||
&& (!want_type
|
||
|| TREE_CODE (field) == TYPE_DECL
|
||
|| DECL_CLASS_TEMPLATE_P (field)))
|
||
return field;
|
||
}
|
||
/* Not found. */
|
||
if (name == vptr_identifier)
|
||
{
|
||
/* Give the user what s/he thinks s/he wants. */
|
||
if (TYPE_POLYMORPHIC_P (type))
|
||
return TYPE_VFIELD (type);
|
||
}
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* Return the FUNCTION_DECL, RECORD_TYPE, UNION_TYPE, or
|
||
NAMESPACE_DECL corresponding to the innermost non-block scope. */
|
||
|
||
tree
|
||
current_scope (void)
|
||
{
|
||
/* There are a number of cases we need to be aware of here:
|
||
current_class_type current_function_decl
|
||
global NULL NULL
|
||
fn-local NULL SET
|
||
class-local SET NULL
|
||
class->fn SET SET
|
||
fn->class SET SET
|
||
|
||
Those last two make life interesting. If we're in a function which is
|
||
itself inside a class, we need decls to go into the fn's decls (our
|
||
second case below). But if we're in a class and the class itself is
|
||
inside a function, we need decls to go into the decls for the class. To
|
||
achieve this last goal, we must see if, when both current_class_ptr and
|
||
current_function_decl are set, the class was declared inside that
|
||
function. If so, we know to put the decls into the class's scope. */
|
||
if (current_function_decl && current_class_type
|
||
&& ((DECL_FUNCTION_MEMBER_P (current_function_decl)
|
||
&& same_type_p (DECL_CONTEXT (current_function_decl),
|
||
current_class_type))
|
||
|| (DECL_FRIEND_CONTEXT (current_function_decl)
|
||
&& same_type_p (DECL_FRIEND_CONTEXT (current_function_decl),
|
||
current_class_type))))
|
||
return current_function_decl;
|
||
if (current_class_type)
|
||
return current_class_type;
|
||
if (current_function_decl)
|
||
return current_function_decl;
|
||
return current_namespace;
|
||
}
|
||
|
||
/* Returns nonzero if we are currently in a function scope. Note
|
||
that this function returns zero if we are within a local class, but
|
||
not within a member function body of the local class. */
|
||
|
||
int
|
||
at_function_scope_p (void)
|
||
{
|
||
tree cs = current_scope ();
|
||
return cs && TREE_CODE (cs) == FUNCTION_DECL;
|
||
}
|
||
|
||
/* Returns true if the innermost active scope is a class scope. */
|
||
|
||
bool
|
||
at_class_scope_p (void)
|
||
{
|
||
tree cs = current_scope ();
|
||
return cs && TYPE_P (cs);
|
||
}
|
||
|
||
/* Returns true if the innermost active scope is a namespace scope. */
|
||
|
||
bool
|
||
at_namespace_scope_p (void)
|
||
{
|
||
tree cs = current_scope ();
|
||
return cs && TREE_CODE (cs) == NAMESPACE_DECL;
|
||
}
|
||
|
||
/* Return the scope of DECL, as appropriate when doing name-lookup. */
|
||
|
||
tree
|
||
context_for_name_lookup (tree decl)
|
||
{
|
||
/* [class.union]
|
||
|
||
For the purposes of name lookup, after the anonymous union
|
||
definition, the members of the anonymous union are considered to
|
||
have been defined in the scope in which the anonymous union is
|
||
declared. */
|
||
tree context = DECL_CONTEXT (decl);
|
||
|
||
while (context && TYPE_P (context) && ANON_AGGR_TYPE_P (context))
|
||
context = TYPE_CONTEXT (context);
|
||
if (!context)
|
||
context = global_namespace;
|
||
|
||
return context;
|
||
}
|
||
|
||
/* The accessibility routines use BINFO_ACCESS for scratch space
|
||
during the computation of the accessibility of some declaration. */
|
||
|
||
#define BINFO_ACCESS(NODE) \
|
||
((access_kind) ((TREE_PUBLIC (NODE) << 1) | TREE_PRIVATE (NODE)))
|
||
|
||
/* Set the access associated with NODE to ACCESS. */
|
||
|
||
#define SET_BINFO_ACCESS(NODE, ACCESS) \
|
||
((TREE_PUBLIC (NODE) = ((ACCESS) & 2) != 0), \
|
||
(TREE_PRIVATE (NODE) = ((ACCESS) & 1) != 0))
|
||
|
||
/* Called from access_in_type via dfs_walk. Calculate the access to
|
||
DATA (which is really a DECL) in BINFO. */
|
||
|
||
static tree
|
||
dfs_access_in_type (tree binfo, void *data)
|
||
{
|
||
tree decl = (tree) data;
|
||
tree type = BINFO_TYPE (binfo);
|
||
access_kind access = ak_none;
|
||
|
||
if (context_for_name_lookup (decl) == type)
|
||
{
|
||
/* If we have descended to the scope of DECL, just note the
|
||
appropriate access. */
|
||
if (TREE_PRIVATE (decl))
|
||
access = ak_private;
|
||
else if (TREE_PROTECTED (decl))
|
||
access = ak_protected;
|
||
else
|
||
access = ak_public;
|
||
}
|
||
else
|
||
{
|
||
/* First, check for an access-declaration that gives us more
|
||
access to the DECL. The CONST_DECL for an enumeration
|
||
constant will not have DECL_LANG_SPECIFIC, and thus no
|
||
DECL_ACCESS. */
|
||
if (DECL_LANG_SPECIFIC (decl) && !DECL_DISCRIMINATOR_P (decl))
|
||
{
|
||
tree decl_access = purpose_member (type, DECL_ACCESS (decl));
|
||
|
||
if (decl_access)
|
||
{
|
||
decl_access = TREE_VALUE (decl_access);
|
||
|
||
if (decl_access == access_public_node)
|
||
access = ak_public;
|
||
else if (decl_access == access_protected_node)
|
||
access = ak_protected;
|
||
else if (decl_access == access_private_node)
|
||
access = ak_private;
|
||
else
|
||
gcc_unreachable ();
|
||
}
|
||
}
|
||
|
||
if (!access)
|
||
{
|
||
int i;
|
||
tree base_binfo;
|
||
VEC(tree,gc) *accesses;
|
||
|
||
/* Otherwise, scan our baseclasses, and pick the most favorable
|
||
access. */
|
||
accesses = BINFO_BASE_ACCESSES (binfo);
|
||
for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
|
||
{
|
||
tree base_access = VEC_index (tree, accesses, i);
|
||
access_kind base_access_now = BINFO_ACCESS (base_binfo);
|
||
|
||
if (base_access_now == ak_none || base_access_now == ak_private)
|
||
/* If it was not accessible in the base, or only
|
||
accessible as a private member, we can't access it
|
||
all. */
|
||
base_access_now = ak_none;
|
||
else if (base_access == access_protected_node)
|
||
/* Public and protected members in the base become
|
||
protected here. */
|
||
base_access_now = ak_protected;
|
||
else if (base_access == access_private_node)
|
||
/* Public and protected members in the base become
|
||
private here. */
|
||
base_access_now = ak_private;
|
||
|
||
/* See if the new access, via this base, gives more
|
||
access than our previous best access. */
|
||
if (base_access_now != ak_none
|
||
&& (access == ak_none || base_access_now < access))
|
||
{
|
||
access = base_access_now;
|
||
|
||
/* If the new access is public, we can't do better. */
|
||
if (access == ak_public)
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Note the access to DECL in TYPE. */
|
||
SET_BINFO_ACCESS (binfo, access);
|
||
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* Return the access to DECL in TYPE. */
|
||
|
||
static access_kind
|
||
access_in_type (tree type, tree decl)
|
||
{
|
||
tree binfo = TYPE_BINFO (type);
|
||
|
||
/* We must take into account
|
||
|
||
[class.paths]
|
||
|
||
If a name can be reached by several paths through a multiple
|
||
inheritance graph, the access is that of the path that gives
|
||
most access.
|
||
|
||
The algorithm we use is to make a post-order depth-first traversal
|
||
of the base-class hierarchy. As we come up the tree, we annotate
|
||
each node with the most lenient access. */
|
||
dfs_walk_once (binfo, NULL, dfs_access_in_type, decl);
|
||
|
||
return BINFO_ACCESS (binfo);
|
||
}
|
||
|
||
/* Returns nonzero if it is OK to access DECL through an object
|
||
indicated by BINFO in the context of DERIVED. */
|
||
|
||
static int
|
||
protected_accessible_p (tree decl, tree derived, tree binfo)
|
||
{
|
||
access_kind access;
|
||
|
||
/* We're checking this clause from [class.access.base]
|
||
|
||
m as a member of N is protected, and the reference occurs in a
|
||
member or friend of class N, or in a member or friend of a
|
||
class P derived from N, where m as a member of P is private or
|
||
protected.
|
||
|
||
Here DERIVED is a possible P and DECL is m. accessible_p will
|
||
iterate over various values of N, but the access to m in DERIVED
|
||
does not change.
|
||
|
||
Note that I believe that the passage above is wrong, and should read
|
||
"...is private or protected or public"; otherwise you get bizarre results
|
||
whereby a public using-decl can prevent you from accessing a protected
|
||
member of a base. (jason 2000/02/28) */
|
||
|
||
/* If DERIVED isn't derived from m's class, then it can't be a P. */
|
||
if (!DERIVED_FROM_P (context_for_name_lookup (decl), derived))
|
||
return 0;
|
||
|
||
access = access_in_type (derived, decl);
|
||
|
||
/* If m is inaccessible in DERIVED, then it's not a P. */
|
||
if (access == ak_none)
|
||
return 0;
|
||
|
||
/* [class.protected]
|
||
|
||
When a friend or a member function of a derived class references
|
||
a protected nonstatic member of a base class, an access check
|
||
applies in addition to those described earlier in clause
|
||
_class.access_) Except when forming a pointer to member
|
||
(_expr.unary.op_), the access must be through a pointer to,
|
||
reference to, or object of the derived class itself (or any class
|
||
derived from that class) (_expr.ref_). If the access is to form
|
||
a pointer to member, the nested-name-specifier shall name the
|
||
derived class (or any class derived from that class). */
|
||
if (DECL_NONSTATIC_MEMBER_P (decl))
|
||
{
|
||
/* We can tell through what the reference is occurring by
|
||
chasing BINFO up to the root. */
|
||
tree t = binfo;
|
||
while (BINFO_INHERITANCE_CHAIN (t))
|
||
t = BINFO_INHERITANCE_CHAIN (t);
|
||
|
||
if (!DERIVED_FROM_P (derived, BINFO_TYPE (t)))
|
||
return 0;
|
||
}
|
||
|
||
return 1;
|
||
}
|
||
|
||
/* Returns nonzero if SCOPE is a friend of a type which would be able
|
||
to access DECL through the object indicated by BINFO. */
|
||
|
||
static int
|
||
friend_accessible_p (tree scope, tree decl, tree binfo)
|
||
{
|
||
tree befriending_classes;
|
||
tree t;
|
||
|
||
if (!scope)
|
||
return 0;
|
||
|
||
if (TREE_CODE (scope) == FUNCTION_DECL
|
||
|| DECL_FUNCTION_TEMPLATE_P (scope))
|
||
befriending_classes = DECL_BEFRIENDING_CLASSES (scope);
|
||
else if (TYPE_P (scope))
|
||
befriending_classes = CLASSTYPE_BEFRIENDING_CLASSES (scope);
|
||
else
|
||
return 0;
|
||
|
||
for (t = befriending_classes; t; t = TREE_CHAIN (t))
|
||
if (protected_accessible_p (decl, TREE_VALUE (t), binfo))
|
||
return 1;
|
||
|
||
/* Nested classes have the same access as their enclosing types, as
|
||
per DR 45 (this is a change from the standard). */
|
||
if (TYPE_P (scope))
|
||
for (t = TYPE_CONTEXT (scope); t && TYPE_P (t); t = TYPE_CONTEXT (t))
|
||
if (protected_accessible_p (decl, t, binfo))
|
||
return 1;
|
||
|
||
if (TREE_CODE (scope) == FUNCTION_DECL
|
||
|| DECL_FUNCTION_TEMPLATE_P (scope))
|
||
{
|
||
/* Perhaps this SCOPE is a member of a class which is a
|
||
friend. */
|
||
if (DECL_CLASS_SCOPE_P (scope)
|
||
&& friend_accessible_p (DECL_CONTEXT (scope), decl, binfo))
|
||
return 1;
|
||
|
||
/* Or an instantiation of something which is a friend. */
|
||
if (DECL_TEMPLATE_INFO (scope))
|
||
{
|
||
int ret;
|
||
/* Increment processing_template_decl to make sure that
|
||
dependent_type_p works correctly. */
|
||
++processing_template_decl;
|
||
ret = friend_accessible_p (DECL_TI_TEMPLATE (scope), decl, binfo);
|
||
--processing_template_decl;
|
||
return ret;
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Called via dfs_walk_once_accessible from accessible_p */
|
||
|
||
static tree
|
||
dfs_accessible_post (tree binfo, void *data ATTRIBUTE_UNUSED)
|
||
{
|
||
if (BINFO_ACCESS (binfo) != ak_none)
|
||
{
|
||
tree scope = current_scope ();
|
||
if (scope && TREE_CODE (scope) != NAMESPACE_DECL
|
||
&& is_friend (BINFO_TYPE (binfo), scope))
|
||
return binfo;
|
||
}
|
||
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* DECL is a declaration from a base class of TYPE, which was the
|
||
class used to name DECL. Return nonzero if, in the current
|
||
context, DECL is accessible. If TYPE is actually a BINFO node,
|
||
then we can tell in what context the access is occurring by looking
|
||
at the most derived class along the path indicated by BINFO. If
|
||
CONSIDER_LOCAL is true, do consider special access the current
|
||
scope or friendship thereof we might have. */
|
||
|
||
int
|
||
accessible_p (tree type, tree decl, bool consider_local_p)
|
||
{
|
||
tree binfo;
|
||
tree scope;
|
||
access_kind access;
|
||
|
||
/* Nonzero if it's OK to access DECL if it has protected
|
||
accessibility in TYPE. */
|
||
int protected_ok = 0;
|
||
|
||
/* If this declaration is in a block or namespace scope, there's no
|
||
access control. */
|
||
if (!TYPE_P (context_for_name_lookup (decl)))
|
||
return 1;
|
||
|
||
/* There is no need to perform access checks inside a thunk. */
|
||
scope = current_scope ();
|
||
if (scope && DECL_THUNK_P (scope))
|
||
return 1;
|
||
|
||
/* In a template declaration, we cannot be sure whether the
|
||
particular specialization that is instantiated will be a friend
|
||
or not. Therefore, all access checks are deferred until
|
||
instantiation. However, PROCESSING_TEMPLATE_DECL is set in the
|
||
parameter list for a template (because we may see dependent types
|
||
in default arguments for template parameters), and access
|
||
checking should be performed in the outermost parameter list. */
|
||
if (processing_template_decl
|
||
&& (!processing_template_parmlist || processing_template_decl > 1))
|
||
return 1;
|
||
|
||
if (!TYPE_P (type))
|
||
{
|
||
binfo = type;
|
||
type = BINFO_TYPE (type);
|
||
}
|
||
else
|
||
binfo = TYPE_BINFO (type);
|
||
|
||
/* [class.access.base]
|
||
|
||
A member m is accessible when named in class N if
|
||
|
||
--m as a member of N is public, or
|
||
|
||
--m as a member of N is private, and the reference occurs in a
|
||
member or friend of class N, or
|
||
|
||
--m as a member of N is protected, and the reference occurs in a
|
||
member or friend of class N, or in a member or friend of a
|
||
class P derived from N, where m as a member of P is private or
|
||
protected, or
|
||
|
||
--there exists a base class B of N that is accessible at the point
|
||
of reference, and m is accessible when named in class B.
|
||
|
||
We walk the base class hierarchy, checking these conditions. */
|
||
|
||
if (consider_local_p)
|
||
{
|
||
/* Figure out where the reference is occurring. Check to see if
|
||
DECL is private or protected in this scope, since that will
|
||
determine whether protected access is allowed. */
|
||
if (current_class_type)
|
||
protected_ok = protected_accessible_p (decl,
|
||
current_class_type, binfo);
|
||
|
||
/* Now, loop through the classes of which we are a friend. */
|
||
if (!protected_ok)
|
||
protected_ok = friend_accessible_p (scope, decl, binfo);
|
||
}
|
||
|
||
/* Standardize the binfo that access_in_type will use. We don't
|
||
need to know what path was chosen from this point onwards. */
|
||
binfo = TYPE_BINFO (type);
|
||
|
||
/* Compute the accessibility of DECL in the class hierarchy
|
||
dominated by type. */
|
||
access = access_in_type (type, decl);
|
||
if (access == ak_public
|
||
|| (access == ak_protected && protected_ok))
|
||
return 1;
|
||
|
||
if (!consider_local_p)
|
||
return 0;
|
||
|
||
/* Walk the hierarchy again, looking for a base class that allows
|
||
access. */
|
||
return dfs_walk_once_accessible (binfo, /*friends=*/true,
|
||
NULL, dfs_accessible_post, NULL)
|
||
!= NULL_TREE;
|
||
}
|
||
|
||
struct lookup_field_info {
|
||
/* The type in which we're looking. */
|
||
tree type;
|
||
/* The name of the field for which we're looking. */
|
||
tree name;
|
||
/* If non-NULL, the current result of the lookup. */
|
||
tree rval;
|
||
/* The path to RVAL. */
|
||
tree rval_binfo;
|
||
/* If non-NULL, the lookup was ambiguous, and this is a list of the
|
||
candidates. */
|
||
tree ambiguous;
|
||
/* If nonzero, we are looking for types, not data members. */
|
||
int want_type;
|
||
/* If something went wrong, a message indicating what. */
|
||
const char *errstr;
|
||
};
|
||
|
||
/* Within the scope of a template class, you can refer to the to the
|
||
current specialization with the name of the template itself. For
|
||
example:
|
||
|
||
template <typename T> struct S { S* sp; }
|
||
|
||
Returns nonzero if DECL is such a declaration in a class TYPE. */
|
||
|
||
static int
|
||
template_self_reference_p (tree type, tree decl)
|
||
{
|
||
return (CLASSTYPE_USE_TEMPLATE (type)
|
||
&& PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type))
|
||
&& TREE_CODE (decl) == TYPE_DECL
|
||
&& DECL_ARTIFICIAL (decl)
|
||
&& DECL_NAME (decl) == constructor_name (type));
|
||
}
|
||
|
||
/* Nonzero for a class member means that it is shared between all objects
|
||
of that class.
|
||
|
||
[class.member.lookup]:If the resulting set of declarations are not all
|
||
from sub-objects of the same type, or the set has a nonstatic member
|
||
and includes members from distinct sub-objects, there is an ambiguity
|
||
and the program is ill-formed.
|
||
|
||
This function checks that T contains no nonstatic members. */
|
||
|
||
int
|
||
shared_member_p (tree t)
|
||
{
|
||
if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == TYPE_DECL \
|
||
|| TREE_CODE (t) == CONST_DECL)
|
||
return 1;
|
||
if (is_overloaded_fn (t))
|
||
{
|
||
for (; t; t = OVL_NEXT (t))
|
||
{
|
||
tree fn = OVL_CURRENT (t);
|
||
if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
|
||
return 0;
|
||
}
|
||
return 1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/* Routine to see if the sub-object denoted by the binfo PARENT can be
|
||
found as a base class and sub-object of the object denoted by
|
||
BINFO. */
|
||
|
||
static int
|
||
is_subobject_of_p (tree parent, tree binfo)
|
||
{
|
||
tree probe;
|
||
|
||
for (probe = parent; probe; probe = BINFO_INHERITANCE_CHAIN (probe))
|
||
{
|
||
if (probe == binfo)
|
||
return 1;
|
||
if (BINFO_VIRTUAL_P (probe))
|
||
return (binfo_for_vbase (BINFO_TYPE (probe), BINFO_TYPE (binfo))
|
||
!= NULL_TREE);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/* DATA is really a struct lookup_field_info. Look for a field with
|
||
the name indicated there in BINFO. If this function returns a
|
||
non-NULL value it is the result of the lookup. Called from
|
||
lookup_field via breadth_first_search. */
|
||
|
||
static tree
|
||
lookup_field_r (tree binfo, void *data)
|
||
{
|
||
struct lookup_field_info *lfi = (struct lookup_field_info *) data;
|
||
tree type = BINFO_TYPE (binfo);
|
||
tree nval = NULL_TREE;
|
||
|
||
/* If this is a dependent base, don't look in it. */
|
||
if (BINFO_DEPENDENT_BASE_P (binfo))
|
||
return NULL_TREE;
|
||
|
||
/* If this base class is hidden by the best-known value so far, we
|
||
don't need to look. */
|
||
if (lfi->rval_binfo && BINFO_INHERITANCE_CHAIN (binfo) == lfi->rval_binfo
|
||
&& !BINFO_VIRTUAL_P (binfo))
|
||
return dfs_skip_bases;
|
||
|
||
/* First, look for a function. There can't be a function and a data
|
||
member with the same name, and if there's a function and a type
|
||
with the same name, the type is hidden by the function. */
|
||
if (!lfi->want_type)
|
||
{
|
||
int idx = lookup_fnfields_1 (type, lfi->name);
|
||
if (idx >= 0)
|
||
nval = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), idx);
|
||
}
|
||
|
||
if (!nval)
|
||
/* Look for a data member or type. */
|
||
nval = lookup_field_1 (type, lfi->name, lfi->want_type);
|
||
|
||
/* If there is no declaration with the indicated name in this type,
|
||
then there's nothing to do. */
|
||
if (!nval)
|
||
goto done;
|
||
|
||
/* If we're looking up a type (as with an elaborated type specifier)
|
||
we ignore all non-types we find. */
|
||
if (lfi->want_type && TREE_CODE (nval) != TYPE_DECL
|
||
&& !DECL_CLASS_TEMPLATE_P (nval))
|
||
{
|
||
if (lfi->name == TYPE_IDENTIFIER (type))
|
||
{
|
||
/* If the aggregate has no user defined constructors, we allow
|
||
it to have fields with the same name as the enclosing type.
|
||
If we are looking for that name, find the corresponding
|
||
TYPE_DECL. */
|
||
for (nval = TREE_CHAIN (nval); nval; nval = TREE_CHAIN (nval))
|
||
if (DECL_NAME (nval) == lfi->name
|
||
&& TREE_CODE (nval) == TYPE_DECL)
|
||
break;
|
||
}
|
||
else
|
||
nval = NULL_TREE;
|
||
if (!nval && CLASSTYPE_NESTED_UTDS (type) != NULL)
|
||
{
|
||
binding_entry e = binding_table_find (CLASSTYPE_NESTED_UTDS (type),
|
||
lfi->name);
|
||
if (e != NULL)
|
||
nval = TYPE_MAIN_DECL (e->type);
|
||
else
|
||
goto done;
|
||
}
|
||
}
|
||
|
||
/* You must name a template base class with a template-id. */
|
||
if (!same_type_p (type, lfi->type)
|
||
&& template_self_reference_p (type, nval))
|
||
goto done;
|
||
|
||
/* If the lookup already found a match, and the new value doesn't
|
||
hide the old one, we might have an ambiguity. */
|
||
if (lfi->rval_binfo
|
||
&& !is_subobject_of_p (lfi->rval_binfo, binfo))
|
||
|
||
{
|
||
if (nval == lfi->rval && shared_member_p (nval))
|
||
/* The two things are really the same. */
|
||
;
|
||
else if (is_subobject_of_p (binfo, lfi->rval_binfo))
|
||
/* The previous value hides the new one. */
|
||
;
|
||
else
|
||
{
|
||
/* We have a real ambiguity. We keep a chain of all the
|
||
candidates. */
|
||
if (!lfi->ambiguous && lfi->rval)
|
||
{
|
||
/* This is the first time we noticed an ambiguity. Add
|
||
what we previously thought was a reasonable candidate
|
||
to the list. */
|
||
lfi->ambiguous = tree_cons (NULL_TREE, lfi->rval, NULL_TREE);
|
||
TREE_TYPE (lfi->ambiguous) = error_mark_node;
|
||
}
|
||
|
||
/* Add the new value. */
|
||
lfi->ambiguous = tree_cons (NULL_TREE, nval, lfi->ambiguous);
|
||
TREE_TYPE (lfi->ambiguous) = error_mark_node;
|
||
lfi->errstr = "request for member %qD is ambiguous";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
lfi->rval = nval;
|
||
lfi->rval_binfo = binfo;
|
||
}
|
||
|
||
done:
|
||
/* Don't look for constructors or destructors in base classes. */
|
||
if (IDENTIFIER_CTOR_OR_DTOR_P (lfi->name))
|
||
return dfs_skip_bases;
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* Return a "baselink" with BASELINK_BINFO, BASELINK_ACCESS_BINFO,
|
||
BASELINK_FUNCTIONS, and BASELINK_OPTYPE set to BINFO, ACCESS_BINFO,
|
||
FUNCTIONS, and OPTYPE respectively. */
|
||
|
||
tree
|
||
build_baselink (tree binfo, tree access_binfo, tree functions, tree optype)
|
||
{
|
||
tree baselink;
|
||
|
||
gcc_assert (TREE_CODE (functions) == FUNCTION_DECL
|
||
|| TREE_CODE (functions) == TEMPLATE_DECL
|
||
|| TREE_CODE (functions) == TEMPLATE_ID_EXPR
|
||
|| TREE_CODE (functions) == OVERLOAD);
|
||
gcc_assert (!optype || TYPE_P (optype));
|
||
gcc_assert (TREE_TYPE (functions));
|
||
|
||
baselink = make_node (BASELINK);
|
||
TREE_TYPE (baselink) = TREE_TYPE (functions);
|
||
BASELINK_BINFO (baselink) = binfo;
|
||
BASELINK_ACCESS_BINFO (baselink) = access_binfo;
|
||
BASELINK_FUNCTIONS (baselink) = functions;
|
||
BASELINK_OPTYPE (baselink) = optype;
|
||
|
||
return baselink;
|
||
}
|
||
|
||
/* Look for a member named NAME in an inheritance lattice dominated by
|
||
XBASETYPE. If PROTECT is 0 or two, we do not check access. If it
|
||
is 1, we enforce accessibility. If PROTECT is zero, then, for an
|
||
ambiguous lookup, we return NULL. If PROTECT is 1, we issue error
|
||
messages about inaccessible or ambiguous lookup. If PROTECT is 2,
|
||
we return a TREE_LIST whose TREE_TYPE is error_mark_node and whose
|
||
TREE_VALUEs are the list of ambiguous candidates.
|
||
|
||
WANT_TYPE is 1 when we should only return TYPE_DECLs.
|
||
|
||
If nothing can be found return NULL_TREE and do not issue an error. */
|
||
|
||
tree
|
||
lookup_member (tree xbasetype, tree name, int protect, bool want_type)
|
||
{
|
||
tree rval, rval_binfo = NULL_TREE;
|
||
tree type = NULL_TREE, basetype_path = NULL_TREE;
|
||
struct lookup_field_info lfi;
|
||
|
||
/* rval_binfo is the binfo associated with the found member, note,
|
||
this can be set with useful information, even when rval is not
|
||
set, because it must deal with ALL members, not just non-function
|
||
members. It is used for ambiguity checking and the hidden
|
||
checks. Whereas rval is only set if a proper (not hidden)
|
||
non-function member is found. */
|
||
|
||
const char *errstr = 0;
|
||
|
||
gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
|
||
|
||
if (TREE_CODE (xbasetype) == TREE_BINFO)
|
||
{
|
||
type = BINFO_TYPE (xbasetype);
|
||
basetype_path = xbasetype;
|
||
}
|
||
else
|
||
{
|
||
if (!IS_AGGR_TYPE_CODE (TREE_CODE (xbasetype)))
|
||
return NULL_TREE;
|
||
type = xbasetype;
|
||
xbasetype = NULL_TREE;
|
||
}
|
||
|
||
type = complete_type (type);
|
||
if (!basetype_path)
|
||
basetype_path = TYPE_BINFO (type);
|
||
|
||
if (!basetype_path)
|
||
return NULL_TREE;
|
||
|
||
#ifdef GATHER_STATISTICS
|
||
n_calls_lookup_field++;
|
||
#endif /* GATHER_STATISTICS */
|
||
|
||
memset (&lfi, 0, sizeof (lfi));
|
||
lfi.type = type;
|
||
lfi.name = name;
|
||
lfi.want_type = want_type;
|
||
dfs_walk_all (basetype_path, &lookup_field_r, NULL, &lfi);
|
||
rval = lfi.rval;
|
||
rval_binfo = lfi.rval_binfo;
|
||
if (rval_binfo)
|
||
type = BINFO_TYPE (rval_binfo);
|
||
errstr = lfi.errstr;
|
||
|
||
/* If we are not interested in ambiguities, don't report them;
|
||
just return NULL_TREE. */
|
||
if (!protect && lfi.ambiguous)
|
||
return NULL_TREE;
|
||
|
||
if (protect == 2)
|
||
{
|
||
if (lfi.ambiguous)
|
||
return lfi.ambiguous;
|
||
else
|
||
protect = 0;
|
||
}
|
||
|
||
/* [class.access]
|
||
|
||
In the case of overloaded function names, access control is
|
||
applied to the function selected by overloaded resolution.
|
||
|
||
We cannot check here, even if RVAL is only a single non-static
|
||
member function, since we do not know what the "this" pointer
|
||
will be. For:
|
||
|
||
class A { protected: void f(); };
|
||
class B : public A {
|
||
void g(A *p) {
|
||
f(); // OK
|
||
p->f(); // Not OK.
|
||
}
|
||
};
|
||
|
||
only the first call to "f" is valid. However, if the function is
|
||
static, we can check. */
|
||
if (rval && protect
|
||
&& !really_overloaded_fn (rval)
|
||
&& !(TREE_CODE (rval) == FUNCTION_DECL
|
||
&& DECL_NONSTATIC_MEMBER_FUNCTION_P (rval)))
|
||
perform_or_defer_access_check (basetype_path, rval, rval);
|
||
|
||
if (errstr && protect)
|
||
{
|
||
error (errstr, name, type);
|
||
if (lfi.ambiguous)
|
||
print_candidates (lfi.ambiguous);
|
||
rval = error_mark_node;
|
||
}
|
||
|
||
if (rval && is_overloaded_fn (rval))
|
||
rval = build_baselink (rval_binfo, basetype_path, rval,
|
||
(IDENTIFIER_TYPENAME_P (name)
|
||
? TREE_TYPE (name): NULL_TREE));
|
||
return rval;
|
||
}
|
||
|
||
/* Like lookup_member, except that if we find a function member we
|
||
return NULL_TREE. */
|
||
|
||
tree
|
||
lookup_field (tree xbasetype, tree name, int protect, bool want_type)
|
||
{
|
||
tree rval = lookup_member (xbasetype, name, protect, want_type);
|
||
|
||
/* Ignore functions, but propagate the ambiguity list. */
|
||
if (!error_operand_p (rval)
|
||
&& (rval && BASELINK_P (rval)))
|
||
return NULL_TREE;
|
||
|
||
return rval;
|
||
}
|
||
|
||
/* Like lookup_member, except that if we find a non-function member we
|
||
return NULL_TREE. */
|
||
|
||
tree
|
||
lookup_fnfields (tree xbasetype, tree name, int protect)
|
||
{
|
||
tree rval = lookup_member (xbasetype, name, protect, /*want_type=*/false);
|
||
|
||
/* Ignore non-functions, but propagate the ambiguity list. */
|
||
if (!error_operand_p (rval)
|
||
&& (rval && !BASELINK_P (rval)))
|
||
return NULL_TREE;
|
||
|
||
return rval;
|
||
}
|
||
|
||
/* Return the index in the CLASSTYPE_METHOD_VEC for CLASS_TYPE
|
||
corresponding to "operator TYPE ()", or -1 if there is no such
|
||
operator. Only CLASS_TYPE itself is searched; this routine does
|
||
not scan the base classes of CLASS_TYPE. */
|
||
|
||
static int
|
||
lookup_conversion_operator (tree class_type, tree type)
|
||
{
|
||
int tpl_slot = -1;
|
||
|
||
if (TYPE_HAS_CONVERSION (class_type))
|
||
{
|
||
int i;
|
||
tree fn;
|
||
VEC(tree,gc) *methods = CLASSTYPE_METHOD_VEC (class_type);
|
||
|
||
for (i = CLASSTYPE_FIRST_CONVERSION_SLOT;
|
||
VEC_iterate (tree, methods, i, fn); ++i)
|
||
{
|
||
/* All the conversion operators come near the beginning of
|
||
the class. Therefore, if FN is not a conversion
|
||
operator, there is no matching conversion operator in
|
||
CLASS_TYPE. */
|
||
fn = OVL_CURRENT (fn);
|
||
if (!DECL_CONV_FN_P (fn))
|
||
break;
|
||
|
||
if (TREE_CODE (fn) == TEMPLATE_DECL)
|
||
/* All the templated conversion functions are on the same
|
||
slot, so remember it. */
|
||
tpl_slot = i;
|
||
else if (same_type_p (DECL_CONV_FN_TYPE (fn), type))
|
||
return i;
|
||
}
|
||
}
|
||
|
||
return tpl_slot;
|
||
}
|
||
|
||
/* TYPE is a class type. Return the index of the fields within
|
||
the method vector with name NAME, or -1 is no such field exists. */
|
||
|
||
int
|
||
lookup_fnfields_1 (tree type, tree name)
|
||
{
|
||
VEC(tree,gc) *method_vec;
|
||
tree fn;
|
||
tree tmp;
|
||
size_t i;
|
||
|
||
if (!CLASS_TYPE_P (type))
|
||
return -1;
|
||
|
||
if (COMPLETE_TYPE_P (type))
|
||
{
|
||
if ((name == ctor_identifier
|
||
|| name == base_ctor_identifier
|
||
|| name == complete_ctor_identifier))
|
||
{
|
||
if (CLASSTYPE_LAZY_DEFAULT_CTOR (type))
|
||
lazily_declare_fn (sfk_constructor, type);
|
||
if (CLASSTYPE_LAZY_COPY_CTOR (type))
|
||
lazily_declare_fn (sfk_copy_constructor, type);
|
||
}
|
||
else if (name == ansi_assopname(NOP_EXPR)
|
||
&& CLASSTYPE_LAZY_ASSIGNMENT_OP (type))
|
||
lazily_declare_fn (sfk_assignment_operator, type);
|
||
else if ((name == dtor_identifier
|
||
|| name == base_dtor_identifier
|
||
|| name == complete_dtor_identifier
|
||
|| name == deleting_dtor_identifier)
|
||
&& CLASSTYPE_LAZY_DESTRUCTOR (type))
|
||
lazily_declare_fn (sfk_destructor, type);
|
||
}
|
||
|
||
method_vec = CLASSTYPE_METHOD_VEC (type);
|
||
if (!method_vec)
|
||
return -1;
|
||
|
||
#ifdef GATHER_STATISTICS
|
||
n_calls_lookup_fnfields_1++;
|
||
#endif /* GATHER_STATISTICS */
|
||
|
||
/* Constructors are first... */
|
||
if (name == ctor_identifier)
|
||
{
|
||
fn = CLASSTYPE_CONSTRUCTORS (type);
|
||
return fn ? CLASSTYPE_CONSTRUCTOR_SLOT : -1;
|
||
}
|
||
/* and destructors are second. */
|
||
if (name == dtor_identifier)
|
||
{
|
||
fn = CLASSTYPE_DESTRUCTORS (type);
|
||
return fn ? CLASSTYPE_DESTRUCTOR_SLOT : -1;
|
||
}
|
||
if (IDENTIFIER_TYPENAME_P (name))
|
||
return lookup_conversion_operator (type, TREE_TYPE (name));
|
||
|
||
/* Skip the conversion operators. */
|
||
for (i = CLASSTYPE_FIRST_CONVERSION_SLOT;
|
||
VEC_iterate (tree, method_vec, i, fn);
|
||
++i)
|
||
if (!DECL_CONV_FN_P (OVL_CURRENT (fn)))
|
||
break;
|
||
|
||
/* If the type is complete, use binary search. */
|
||
if (COMPLETE_TYPE_P (type))
|
||
{
|
||
int lo;
|
||
int hi;
|
||
|
||
lo = i;
|
||
hi = VEC_length (tree, method_vec);
|
||
while (lo < hi)
|
||
{
|
||
i = (lo + hi) / 2;
|
||
|
||
#ifdef GATHER_STATISTICS
|
||
n_outer_fields_searched++;
|
||
#endif /* GATHER_STATISTICS */
|
||
|
||
tmp = VEC_index (tree, method_vec, i);
|
||
tmp = DECL_NAME (OVL_CURRENT (tmp));
|
||
if (tmp > name)
|
||
hi = i;
|
||
else if (tmp < name)
|
||
lo = i + 1;
|
||
else
|
||
return i;
|
||
}
|
||
}
|
||
else
|
||
for (; VEC_iterate (tree, method_vec, i, fn); ++i)
|
||
{
|
||
#ifdef GATHER_STATISTICS
|
||
n_outer_fields_searched++;
|
||
#endif /* GATHER_STATISTICS */
|
||
if (DECL_NAME (OVL_CURRENT (fn)) == name)
|
||
return i;
|
||
}
|
||
|
||
return -1;
|
||
}
|
||
|
||
/* Like lookup_fnfields_1, except that the name is extracted from
|
||
FUNCTION, which is a FUNCTION_DECL or a TEMPLATE_DECL. */
|
||
|
||
int
|
||
class_method_index_for_fn (tree class_type, tree function)
|
||
{
|
||
gcc_assert (TREE_CODE (function) == FUNCTION_DECL
|
||
|| DECL_FUNCTION_TEMPLATE_P (function));
|
||
|
||
return lookup_fnfields_1 (class_type,
|
||
DECL_CONSTRUCTOR_P (function) ? ctor_identifier :
|
||
DECL_DESTRUCTOR_P (function) ? dtor_identifier :
|
||
DECL_NAME (function));
|
||
}
|
||
|
||
|
||
/* DECL is the result of a qualified name lookup. QUALIFYING_SCOPE is
|
||
the class or namespace used to qualify the name. CONTEXT_CLASS is
|
||
the class corresponding to the object in which DECL will be used.
|
||
Return a possibly modified version of DECL that takes into account
|
||
the CONTEXT_CLASS.
|
||
|
||
In particular, consider an expression like `B::m' in the context of
|
||
a derived class `D'. If `B::m' has been resolved to a BASELINK,
|
||
then the most derived class indicated by the BASELINK_BINFO will be
|
||
`B', not `D'. This function makes that adjustment. */
|
||
|
||
tree
|
||
adjust_result_of_qualified_name_lookup (tree decl,
|
||
tree qualifying_scope,
|
||
tree context_class)
|
||
{
|
||
if (context_class && context_class != error_mark_node
|
||
&& CLASS_TYPE_P (context_class)
|
||
&& CLASS_TYPE_P (qualifying_scope)
|
||
&& DERIVED_FROM_P (qualifying_scope, context_class)
|
||
&& BASELINK_P (decl))
|
||
{
|
||
tree base;
|
||
|
||
/* Look for the QUALIFYING_SCOPE as a base of the CONTEXT_CLASS.
|
||
Because we do not yet know which function will be chosen by
|
||
overload resolution, we cannot yet check either accessibility
|
||
or ambiguity -- in either case, the choice of a static member
|
||
function might make the usage valid. */
|
||
base = lookup_base (context_class, qualifying_scope,
|
||
ba_unique | ba_quiet, NULL);
|
||
if (base)
|
||
{
|
||
BASELINK_ACCESS_BINFO (decl) = base;
|
||
BASELINK_BINFO (decl)
|
||
= lookup_base (base, BINFO_TYPE (BASELINK_BINFO (decl)),
|
||
ba_unique | ba_quiet,
|
||
NULL);
|
||
}
|
||
}
|
||
|
||
return decl;
|
||
}
|
||
|
||
|
||
/* Walk the class hierarchy within BINFO, in a depth-first traversal.
|
||
PRE_FN is called in preorder, while POST_FN is called in postorder.
|
||
If PRE_FN returns DFS_SKIP_BASES, child binfos will not be
|
||
walked. If PRE_FN or POST_FN returns a different non-NULL value,
|
||
that value is immediately returned and the walk is terminated. One
|
||
of PRE_FN and POST_FN can be NULL. At each node, PRE_FN and
|
||
POST_FN are passed the binfo to examine and the caller's DATA
|
||
value. All paths are walked, thus virtual and morally virtual
|
||
binfos can be multiply walked. */
|
||
|
||
tree
|
||
dfs_walk_all (tree binfo, tree (*pre_fn) (tree, void *),
|
||
tree (*post_fn) (tree, void *), void *data)
|
||
{
|
||
tree rval;
|
||
unsigned ix;
|
||
tree base_binfo;
|
||
|
||
/* Call the pre-order walking function. */
|
||
if (pre_fn)
|
||
{
|
||
rval = pre_fn (binfo, data);
|
||
if (rval)
|
||
{
|
||
if (rval == dfs_skip_bases)
|
||
goto skip_bases;
|
||
return rval;
|
||
}
|
||
}
|
||
|
||
/* Find the next child binfo to walk. */
|
||
for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
|
||
{
|
||
rval = dfs_walk_all (base_binfo, pre_fn, post_fn, data);
|
||
if (rval)
|
||
return rval;
|
||
}
|
||
|
||
skip_bases:
|
||
/* Call the post-order walking function. */
|
||
if (post_fn)
|
||
{
|
||
rval = post_fn (binfo, data);
|
||
gcc_assert (rval != dfs_skip_bases);
|
||
return rval;
|
||
}
|
||
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* Worker for dfs_walk_once. This behaves as dfs_walk_all, except
|
||
that binfos are walked at most once. */
|
||
|
||
static tree
|
||
dfs_walk_once_r (tree binfo, tree (*pre_fn) (tree, void *),
|
||
tree (*post_fn) (tree, void *), void *data)
|
||
{
|
||
tree rval;
|
||
unsigned ix;
|
||
tree base_binfo;
|
||
|
||
/* Call the pre-order walking function. */
|
||
if (pre_fn)
|
||
{
|
||
rval = pre_fn (binfo, data);
|
||
if (rval)
|
||
{
|
||
if (rval == dfs_skip_bases)
|
||
goto skip_bases;
|
||
|
||
return rval;
|
||
}
|
||
}
|
||
|
||
/* Find the next child binfo to walk. */
|
||
for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
|
||
{
|
||
if (BINFO_VIRTUAL_P (base_binfo))
|
||
{
|
||
if (BINFO_MARKED (base_binfo))
|
||
continue;
|
||
BINFO_MARKED (base_binfo) = 1;
|
||
}
|
||
|
||
rval = dfs_walk_once_r (base_binfo, pre_fn, post_fn, data);
|
||
if (rval)
|
||
return rval;
|
||
}
|
||
|
||
skip_bases:
|
||
/* Call the post-order walking function. */
|
||
if (post_fn)
|
||
{
|
||
rval = post_fn (binfo, data);
|
||
gcc_assert (rval != dfs_skip_bases);
|
||
return rval;
|
||
}
|
||
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* Worker for dfs_walk_once. Recursively unmark the virtual base binfos of
|
||
BINFO. */
|
||
|
||
static void
|
||
dfs_unmark_r (tree binfo)
|
||
{
|
||
unsigned ix;
|
||
tree base_binfo;
|
||
|
||
/* Process the basetypes. */
|
||
for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
|
||
{
|
||
if (BINFO_VIRTUAL_P (base_binfo))
|
||
{
|
||
if (!BINFO_MARKED (base_binfo))
|
||
continue;
|
||
BINFO_MARKED (base_binfo) = 0;
|
||
}
|
||
/* Only walk, if it can contain more virtual bases. */
|
||
if (CLASSTYPE_VBASECLASSES (BINFO_TYPE (base_binfo)))
|
||
dfs_unmark_r (base_binfo);
|
||
}
|
||
}
|
||
|
||
/* Like dfs_walk_all, except that binfos are not multiply walked. For
|
||
non-diamond shaped hierarchies this is the same as dfs_walk_all.
|
||
For diamond shaped hierarchies we must mark the virtual bases, to
|
||
avoid multiple walks. */
|
||
|
||
tree
|
||
dfs_walk_once (tree binfo, tree (*pre_fn) (tree, void *),
|
||
tree (*post_fn) (tree, void *), void *data)
|
||
{
|
||
static int active = 0; /* We must not be called recursively. */
|
||
tree rval;
|
||
|
||
gcc_assert (pre_fn || post_fn);
|
||
gcc_assert (!active);
|
||
active++;
|
||
|
||
if (!CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo)))
|
||
/* We are not diamond shaped, and therefore cannot encounter the
|
||
same binfo twice. */
|
||
rval = dfs_walk_all (binfo, pre_fn, post_fn, data);
|
||
else
|
||
{
|
||
rval = dfs_walk_once_r (binfo, pre_fn, post_fn, data);
|
||
if (!BINFO_INHERITANCE_CHAIN (binfo))
|
||
{
|
||
/* We are at the top of the hierarchy, and can use the
|
||
CLASSTYPE_VBASECLASSES list for unmarking the virtual
|
||
bases. */
|
||
VEC(tree,gc) *vbases;
|
||
unsigned ix;
|
||
tree base_binfo;
|
||
|
||
for (vbases = CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)), ix = 0;
|
||
VEC_iterate (tree, vbases, ix, base_binfo); ix++)
|
||
BINFO_MARKED (base_binfo) = 0;
|
||
}
|
||
else
|
||
dfs_unmark_r (binfo);
|
||
}
|
||
|
||
active--;
|
||
|
||
return rval;
|
||
}
|
||
|
||
/* Worker function for dfs_walk_once_accessible. Behaves like
|
||
dfs_walk_once_r, except (a) FRIENDS_P is true if special
|
||
access given by the current context should be considered, (b) ONCE
|
||
indicates whether bases should be marked during traversal. */
|
||
|
||
static tree
|
||
dfs_walk_once_accessible_r (tree binfo, bool friends_p, bool once,
|
||
tree (*pre_fn) (tree, void *),
|
||
tree (*post_fn) (tree, void *), void *data)
|
||
{
|
||
tree rval = NULL_TREE;
|
||
unsigned ix;
|
||
tree base_binfo;
|
||
|
||
/* Call the pre-order walking function. */
|
||
if (pre_fn)
|
||
{
|
||
rval = pre_fn (binfo, data);
|
||
if (rval)
|
||
{
|
||
if (rval == dfs_skip_bases)
|
||
goto skip_bases;
|
||
|
||
return rval;
|
||
}
|
||
}
|
||
|
||
/* Find the next child binfo to walk. */
|
||
for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
|
||
{
|
||
bool mark = once && BINFO_VIRTUAL_P (base_binfo);
|
||
|
||
if (mark && BINFO_MARKED (base_binfo))
|
||
continue;
|
||
|
||
/* If the base is inherited via private or protected
|
||
inheritance, then we can't see it, unless we are a friend of
|
||
the current binfo. */
|
||
if (BINFO_BASE_ACCESS (binfo, ix) != access_public_node)
|
||
{
|
||
tree scope;
|
||
if (!friends_p)
|
||
continue;
|
||
scope = current_scope ();
|
||
if (!scope
|
||
|| TREE_CODE (scope) == NAMESPACE_DECL
|
||
|| !is_friend (BINFO_TYPE (binfo), scope))
|
||
continue;
|
||
}
|
||
|
||
if (mark)
|
||
BINFO_MARKED (base_binfo) = 1;
|
||
|
||
rval = dfs_walk_once_accessible_r (base_binfo, friends_p, once,
|
||
pre_fn, post_fn, data);
|
||
if (rval)
|
||
return rval;
|
||
}
|
||
|
||
skip_bases:
|
||
/* Call the post-order walking function. */
|
||
if (post_fn)
|
||
{
|
||
rval = post_fn (binfo, data);
|
||
gcc_assert (rval != dfs_skip_bases);
|
||
return rval;
|
||
}
|
||
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* Like dfs_walk_once except that only accessible bases are walked.
|
||
FRIENDS_P indicates whether friendship of the local context
|
||
should be considered when determining accessibility. */
|
||
|
||
static tree
|
||
dfs_walk_once_accessible (tree binfo, bool friends_p,
|
||
tree (*pre_fn) (tree, void *),
|
||
tree (*post_fn) (tree, void *), void *data)
|
||
{
|
||
bool diamond_shaped = CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo));
|
||
tree rval = dfs_walk_once_accessible_r (binfo, friends_p, diamond_shaped,
|
||
pre_fn, post_fn, data);
|
||
|
||
if (diamond_shaped)
|
||
{
|
||
if (!BINFO_INHERITANCE_CHAIN (binfo))
|
||
{
|
||
/* We are at the top of the hierarchy, and can use the
|
||
CLASSTYPE_VBASECLASSES list for unmarking the virtual
|
||
bases. */
|
||
VEC(tree,gc) *vbases;
|
||
unsigned ix;
|
||
tree base_binfo;
|
||
|
||
for (vbases = CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)), ix = 0;
|
||
VEC_iterate (tree, vbases, ix, base_binfo); ix++)
|
||
BINFO_MARKED (base_binfo) = 0;
|
||
}
|
||
else
|
||
dfs_unmark_r (binfo);
|
||
}
|
||
return rval;
|
||
}
|
||
|
||
/* Check that virtual overrider OVERRIDER is acceptable for base function
|
||
BASEFN. Issue diagnostic, and return zero, if unacceptable. */
|
||
|
||
static int
|
||
check_final_overrider (tree overrider, tree basefn)
|
||
{
|
||
tree over_type = TREE_TYPE (overrider);
|
||
tree base_type = TREE_TYPE (basefn);
|
||
tree over_return = TREE_TYPE (over_type);
|
||
tree base_return = TREE_TYPE (base_type);
|
||
tree over_throw = TYPE_RAISES_EXCEPTIONS (over_type);
|
||
tree base_throw = TYPE_RAISES_EXCEPTIONS (base_type);
|
||
int fail = 0;
|
||
|
||
if (DECL_INVALID_OVERRIDER_P (overrider))
|
||
return 0;
|
||
|
||
if (same_type_p (base_return, over_return))
|
||
/* OK */;
|
||
else if ((CLASS_TYPE_P (over_return) && CLASS_TYPE_P (base_return))
|
||
|| (TREE_CODE (base_return) == TREE_CODE (over_return)
|
||
&& POINTER_TYPE_P (base_return)))
|
||
{
|
||
/* Potentially covariant. */
|
||
unsigned base_quals, over_quals;
|
||
|
||
fail = !POINTER_TYPE_P (base_return);
|
||
if (!fail)
|
||
{
|
||
fail = cp_type_quals (base_return) != cp_type_quals (over_return);
|
||
|
||
base_return = TREE_TYPE (base_return);
|
||
over_return = TREE_TYPE (over_return);
|
||
}
|
||
base_quals = cp_type_quals (base_return);
|
||
over_quals = cp_type_quals (over_return);
|
||
|
||
if ((base_quals & over_quals) != over_quals)
|
||
fail = 1;
|
||
|
||
if (CLASS_TYPE_P (base_return) && CLASS_TYPE_P (over_return))
|
||
{
|
||
tree binfo = lookup_base (over_return, base_return,
|
||
ba_check | ba_quiet, NULL);
|
||
|
||
if (!binfo)
|
||
fail = 1;
|
||
}
|
||
else if (!pedantic
|
||
&& can_convert (TREE_TYPE (base_type), TREE_TYPE (over_type)))
|
||
/* GNU extension, allow trivial pointer conversions such as
|
||
converting to void *, or qualification conversion. */
|
||
{
|
||
/* can_convert will permit user defined conversion from a
|
||
(reference to) class type. We must reject them. */
|
||
over_return = non_reference (TREE_TYPE (over_type));
|
||
if (CLASS_TYPE_P (over_return))
|
||
fail = 2;
|
||
else
|
||
{
|
||
warning (0, "deprecated covariant return type for %q+#D",
|
||
overrider);
|
||
warning (0, " overriding %q+#D", basefn);
|
||
}
|
||
}
|
||
else
|
||
fail = 2;
|
||
}
|
||
else
|
||
fail = 2;
|
||
if (!fail)
|
||
/* OK */;
|
||
else
|
||
{
|
||
if (fail == 1)
|
||
{
|
||
error ("invalid covariant return type for %q+#D", overrider);
|
||
error (" overriding %q+#D", basefn);
|
||
}
|
||
else
|
||
{
|
||
error ("conflicting return type specified for %q+#D", overrider);
|
||
error (" overriding %q+#D", basefn);
|
||
}
|
||
DECL_INVALID_OVERRIDER_P (overrider) = 1;
|
||
return 0;
|
||
}
|
||
|
||
/* Check throw specifier is at least as strict. */
|
||
if (!comp_except_specs (base_throw, over_throw, 0))
|
||
{
|
||
error ("looser throw specifier for %q+#F", overrider);
|
||
error (" overriding %q+#F", basefn);
|
||
DECL_INVALID_OVERRIDER_P (overrider) = 1;
|
||
return 0;
|
||
}
|
||
|
||
return 1;
|
||
}
|
||
|
||
/* Given a class TYPE, and a function decl FNDECL, look for
|
||
virtual functions in TYPE's hierarchy which FNDECL overrides.
|
||
We do not look in TYPE itself, only its bases.
|
||
|
||
Returns nonzero, if we find any. Set FNDECL's DECL_VIRTUAL_P, if we
|
||
find that it overrides anything.
|
||
|
||
We check that every function which is overridden, is correctly
|
||
overridden. */
|
||
|
||
int
|
||
look_for_overrides (tree type, tree fndecl)
|
||
{
|
||
tree binfo = TYPE_BINFO (type);
|
||
tree base_binfo;
|
||
int ix;
|
||
int found = 0;
|
||
|
||
for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
|
||
{
|
||
tree basetype = BINFO_TYPE (base_binfo);
|
||
|
||
if (TYPE_POLYMORPHIC_P (basetype))
|
||
found += look_for_overrides_r (basetype, fndecl);
|
||
}
|
||
return found;
|
||
}
|
||
|
||
/* Look in TYPE for virtual functions with the same signature as
|
||
FNDECL. */
|
||
|
||
tree
|
||
look_for_overrides_here (tree type, tree fndecl)
|
||
{
|
||
int ix;
|
||
|
||
/* If there are no methods in TYPE (meaning that only implicitly
|
||
declared methods will ever be provided for TYPE), then there are
|
||
no virtual functions. */
|
||
if (!CLASSTYPE_METHOD_VEC (type))
|
||
return NULL_TREE;
|
||
|
||
if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fndecl))
|
||
ix = CLASSTYPE_DESTRUCTOR_SLOT;
|
||
else
|
||
ix = lookup_fnfields_1 (type, DECL_NAME (fndecl));
|
||
if (ix >= 0)
|
||
{
|
||
tree fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), ix);
|
||
|
||
for (; fns; fns = OVL_NEXT (fns))
|
||
{
|
||
tree fn = OVL_CURRENT (fns);
|
||
|
||
if (!DECL_VIRTUAL_P (fn))
|
||
/* Not a virtual. */;
|
||
else if (DECL_CONTEXT (fn) != type)
|
||
/* Introduced with a using declaration. */;
|
||
else if (DECL_STATIC_FUNCTION_P (fndecl))
|
||
{
|
||
tree btypes = TYPE_ARG_TYPES (TREE_TYPE (fn));
|
||
tree dtypes = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
|
||
if (compparms (TREE_CHAIN (btypes), dtypes))
|
||
return fn;
|
||
}
|
||
else if (same_signature_p (fndecl, fn))
|
||
return fn;
|
||
}
|
||
}
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* Look in TYPE for virtual functions overridden by FNDECL. Check both
|
||
TYPE itself and its bases. */
|
||
|
||
static int
|
||
look_for_overrides_r (tree type, tree fndecl)
|
||
{
|
||
tree fn = look_for_overrides_here (type, fndecl);
|
||
if (fn)
|
||
{
|
||
if (DECL_STATIC_FUNCTION_P (fndecl))
|
||
{
|
||
/* A static member function cannot match an inherited
|
||
virtual member function. */
|
||
error ("%q+#D cannot be declared", fndecl);
|
||
error (" since %q+#D declared in base class", fn);
|
||
}
|
||
else
|
||
{
|
||
/* It's definitely virtual, even if not explicitly set. */
|
||
DECL_VIRTUAL_P (fndecl) = 1;
|
||
check_final_overrider (fndecl, fn);
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
/* We failed to find one declared in this class. Look in its bases. */
|
||
return look_for_overrides (type, fndecl);
|
||
}
|
||
|
||
/* Called via dfs_walk from dfs_get_pure_virtuals. */
|
||
|
||
static tree
|
||
dfs_get_pure_virtuals (tree binfo, void *data)
|
||
{
|
||
tree type = (tree) data;
|
||
|
||
/* We're not interested in primary base classes; the derived class
|
||
of which they are a primary base will contain the information we
|
||
need. */
|
||
if (!BINFO_PRIMARY_P (binfo))
|
||
{
|
||
tree virtuals;
|
||
|
||
for (virtuals = BINFO_VIRTUALS (binfo);
|
||
virtuals;
|
||
virtuals = TREE_CHAIN (virtuals))
|
||
if (DECL_PURE_VIRTUAL_P (BV_FN (virtuals)))
|
||
VEC_safe_push (tree, gc, CLASSTYPE_PURE_VIRTUALS (type),
|
||
BV_FN (virtuals));
|
||
}
|
||
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* Set CLASSTYPE_PURE_VIRTUALS for TYPE. */
|
||
|
||
void
|
||
get_pure_virtuals (tree type)
|
||
{
|
||
/* Clear the CLASSTYPE_PURE_VIRTUALS list; whatever is already there
|
||
is going to be overridden. */
|
||
CLASSTYPE_PURE_VIRTUALS (type) = NULL;
|
||
/* Now, run through all the bases which are not primary bases, and
|
||
collect the pure virtual functions. We look at the vtable in
|
||
each class to determine what pure virtual functions are present.
|
||
(A primary base is not interesting because the derived class of
|
||
which it is a primary base will contain vtable entries for the
|
||
pure virtuals in the base class. */
|
||
dfs_walk_once (TYPE_BINFO (type), NULL, dfs_get_pure_virtuals, type);
|
||
}
|
||
|
||
/* Debug info for C++ classes can get very large; try to avoid
|
||
emitting it everywhere.
|
||
|
||
Note that this optimization wins even when the target supports
|
||
BINCL (if only slightly), and reduces the amount of work for the
|
||
linker. */
|
||
|
||
void
|
||
maybe_suppress_debug_info (tree t)
|
||
{
|
||
if (write_symbols == NO_DEBUG)
|
||
return;
|
||
|
||
/* We might have set this earlier in cp_finish_decl. */
|
||
TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 0;
|
||
|
||
/* Always emit the information for each class every time. */
|
||
if (flag_emit_class_debug_always)
|
||
return;
|
||
|
||
/* If we already know how we're handling this class, handle debug info
|
||
the same way. */
|
||
if (CLASSTYPE_INTERFACE_KNOWN (t))
|
||
{
|
||
if (CLASSTYPE_INTERFACE_ONLY (t))
|
||
TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 1;
|
||
/* else don't set it. */
|
||
}
|
||
/* If the class has a vtable, write out the debug info along with
|
||
the vtable. */
|
||
else if (TYPE_CONTAINS_VPTR_P (t))
|
||
TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 1;
|
||
|
||
/* Otherwise, just emit the debug info normally. */
|
||
}
|
||
|
||
/* Note that we want debugging information for a base class of a class
|
||
whose vtable is being emitted. Normally, this would happen because
|
||
calling the constructor for a derived class implies calling the
|
||
constructors for all bases, which involve initializing the
|
||
appropriate vptr with the vtable for the base class; but in the
|
||
presence of optimization, this initialization may be optimized
|
||
away, so we tell finish_vtable_vardecl that we want the debugging
|
||
information anyway. */
|
||
|
||
static tree
|
||
dfs_debug_mark (tree binfo, void *data ATTRIBUTE_UNUSED)
|
||
{
|
||
tree t = BINFO_TYPE (binfo);
|
||
|
||
if (CLASSTYPE_DEBUG_REQUESTED (t))
|
||
return dfs_skip_bases;
|
||
|
||
CLASSTYPE_DEBUG_REQUESTED (t) = 1;
|
||
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* Write out the debugging information for TYPE, whose vtable is being
|
||
emitted. Also walk through our bases and note that we want to
|
||
write out information for them. This avoids the problem of not
|
||
writing any debug info for intermediate basetypes whose
|
||
constructors, and thus the references to their vtables, and thus
|
||
the vtables themselves, were optimized away. */
|
||
|
||
void
|
||
note_debug_info_needed (tree type)
|
||
{
|
||
if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
|
||
{
|
||
TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)) = 0;
|
||
rest_of_type_compilation (type, toplevel_bindings_p ());
|
||
}
|
||
|
||
dfs_walk_all (TYPE_BINFO (type), dfs_debug_mark, NULL, 0);
|
||
}
|
||
|
||
void
|
||
print_search_statistics (void)
|
||
{
|
||
#ifdef GATHER_STATISTICS
|
||
fprintf (stderr, "%d fields searched in %d[%d] calls to lookup_field[_1]\n",
|
||
n_fields_searched, n_calls_lookup_field, n_calls_lookup_field_1);
|
||
fprintf (stderr, "%d fnfields searched in %d calls to lookup_fnfields\n",
|
||
n_outer_fields_searched, n_calls_lookup_fnfields);
|
||
fprintf (stderr, "%d calls to get_base_type\n", n_calls_get_base_type);
|
||
#else /* GATHER_STATISTICS */
|
||
fprintf (stderr, "no search statistics\n");
|
||
#endif /* GATHER_STATISTICS */
|
||
}
|
||
|
||
void
|
||
reinit_search_statistics (void)
|
||
{
|
||
#ifdef GATHER_STATISTICS
|
||
n_fields_searched = 0;
|
||
n_calls_lookup_field = 0, n_calls_lookup_field_1 = 0;
|
||
n_calls_lookup_fnfields = 0, n_calls_lookup_fnfields_1 = 0;
|
||
n_calls_get_base_type = 0;
|
||
n_outer_fields_searched = 0;
|
||
n_contexts_saved = 0;
|
||
#endif /* GATHER_STATISTICS */
|
||
}
|
||
|
||
/* Helper for lookup_conversions_r. TO_TYPE is the type converted to
|
||
by a conversion op in base BINFO. VIRTUAL_DEPTH is nonzero if
|
||
BINFO is morally virtual, and VIRTUALNESS is nonzero if virtual
|
||
bases have been encountered already in the tree walk. PARENT_CONVS
|
||
is the list of lists of conversion functions that could hide CONV
|
||
and OTHER_CONVS is the list of lists of conversion functions that
|
||
could hide or be hidden by CONV, should virtualness be involved in
|
||
the hierarchy. Merely checking the conversion op's name is not
|
||
enough because two conversion operators to the same type can have
|
||
different names. Return nonzero if we are visible. */
|
||
|
||
static int
|
||
check_hidden_convs (tree binfo, int virtual_depth, int virtualness,
|
||
tree to_type, tree parent_convs, tree other_convs)
|
||
{
|
||
tree level, probe;
|
||
|
||
/* See if we are hidden by a parent conversion. */
|
||
for (level = parent_convs; level; level = TREE_CHAIN (level))
|
||
for (probe = TREE_VALUE (level); probe; probe = TREE_CHAIN (probe))
|
||
if (same_type_p (to_type, TREE_TYPE (probe)))
|
||
return 0;
|
||
|
||
if (virtual_depth || virtualness)
|
||
{
|
||
/* In a virtual hierarchy, we could be hidden, or could hide a
|
||
conversion function on the other_convs list. */
|
||
for (level = other_convs; level; level = TREE_CHAIN (level))
|
||
{
|
||
int we_hide_them;
|
||
int they_hide_us;
|
||
tree *prev, other;
|
||
|
||
if (!(virtual_depth || TREE_STATIC (level)))
|
||
/* Neither is morally virtual, so cannot hide each other. */
|
||
continue;
|
||
|
||
if (!TREE_VALUE (level))
|
||
/* They evaporated away already. */
|
||
continue;
|
||
|
||
they_hide_us = (virtual_depth
|
||
&& original_binfo (binfo, TREE_PURPOSE (level)));
|
||
we_hide_them = (!they_hide_us && TREE_STATIC (level)
|
||
&& original_binfo (TREE_PURPOSE (level), binfo));
|
||
|
||
if (!(we_hide_them || they_hide_us))
|
||
/* Neither is within the other, so no hiding can occur. */
|
||
continue;
|
||
|
||
for (prev = &TREE_VALUE (level), other = *prev; other;)
|
||
{
|
||
if (same_type_p (to_type, TREE_TYPE (other)))
|
||
{
|
||
if (they_hide_us)
|
||
/* We are hidden. */
|
||
return 0;
|
||
|
||
if (we_hide_them)
|
||
{
|
||
/* We hide the other one. */
|
||
other = TREE_CHAIN (other);
|
||
*prev = other;
|
||
continue;
|
||
}
|
||
}
|
||
prev = &TREE_CHAIN (other);
|
||
other = *prev;
|
||
}
|
||
}
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
/* Helper for lookup_conversions_r. PARENT_CONVS is a list of lists
|
||
of conversion functions, the first slot will be for the current
|
||
binfo, if MY_CONVS is non-NULL. CHILD_CONVS is the list of lists
|
||
of conversion functions from children of the current binfo,
|
||
concatenated with conversions from elsewhere in the hierarchy --
|
||
that list begins with OTHER_CONVS. Return a single list of lists
|
||
containing only conversions from the current binfo and its
|
||
children. */
|
||
|
||
static tree
|
||
split_conversions (tree my_convs, tree parent_convs,
|
||
tree child_convs, tree other_convs)
|
||
{
|
||
tree t;
|
||
tree prev;
|
||
|
||
/* Remove the original other_convs portion from child_convs. */
|
||
for (prev = NULL, t = child_convs;
|
||
t != other_convs; prev = t, t = TREE_CHAIN (t))
|
||
continue;
|
||
|
||
if (prev)
|
||
TREE_CHAIN (prev) = NULL_TREE;
|
||
else
|
||
child_convs = NULL_TREE;
|
||
|
||
/* Attach the child convs to any we had at this level. */
|
||
if (my_convs)
|
||
{
|
||
my_convs = parent_convs;
|
||
TREE_CHAIN (my_convs) = child_convs;
|
||
}
|
||
else
|
||
my_convs = child_convs;
|
||
|
||
return my_convs;
|
||
}
|
||
|
||
/* Worker for lookup_conversions. Lookup conversion functions in
|
||
BINFO and its children. VIRTUAL_DEPTH is nonzero, if BINFO is in
|
||
a morally virtual base, and VIRTUALNESS is nonzero, if we've
|
||
encountered virtual bases already in the tree walk. PARENT_CONVS &
|
||
PARENT_TPL_CONVS are lists of list of conversions within parent
|
||
binfos. OTHER_CONVS and OTHER_TPL_CONVS are conversions found
|
||
elsewhere in the tree. Return the conversions found within this
|
||
portion of the graph in CONVS and TPL_CONVS. Return nonzero is we
|
||
encountered virtualness. We keep template and non-template
|
||
conversions separate, to avoid unnecessary type comparisons.
|
||
|
||
The located conversion functions are held in lists of lists. The
|
||
TREE_VALUE of the outer list is the list of conversion functions
|
||
found in a particular binfo. The TREE_PURPOSE of both the outer
|
||
and inner lists is the binfo at which those conversions were
|
||
found. TREE_STATIC is set for those lists within of morally
|
||
virtual binfos. The TREE_VALUE of the inner list is the conversion
|
||
function or overload itself. The TREE_TYPE of each inner list node
|
||
is the converted-to type. */
|
||
|
||
static int
|
||
lookup_conversions_r (tree binfo,
|
||
int virtual_depth, int virtualness,
|
||
tree parent_convs, tree parent_tpl_convs,
|
||
tree other_convs, tree other_tpl_convs,
|
||
tree *convs, tree *tpl_convs)
|
||
{
|
||
int my_virtualness = 0;
|
||
tree my_convs = NULL_TREE;
|
||
tree my_tpl_convs = NULL_TREE;
|
||
tree child_convs = NULL_TREE;
|
||
tree child_tpl_convs = NULL_TREE;
|
||
unsigned i;
|
||
tree base_binfo;
|
||
VEC(tree,gc) *method_vec = CLASSTYPE_METHOD_VEC (BINFO_TYPE (binfo));
|
||
tree conv;
|
||
|
||
/* If we have no conversion operators, then don't look. */
|
||
if (!TYPE_HAS_CONVERSION (BINFO_TYPE (binfo)))
|
||
{
|
||
*convs = *tpl_convs = NULL_TREE;
|
||
|
||
return 0;
|
||
}
|
||
|
||
if (BINFO_VIRTUAL_P (binfo))
|
||
virtual_depth++;
|
||
|
||
/* First, locate the unhidden ones at this level. */
|
||
for (i = CLASSTYPE_FIRST_CONVERSION_SLOT;
|
||
VEC_iterate (tree, method_vec, i, conv);
|
||
++i)
|
||
{
|
||
tree cur = OVL_CURRENT (conv);
|
||
|
||
if (!DECL_CONV_FN_P (cur))
|
||
break;
|
||
|
||
if (TREE_CODE (cur) == TEMPLATE_DECL)
|
||
{
|
||
/* Only template conversions can be overloaded, and we must
|
||
flatten them out and check each one individually. */
|
||
tree tpls;
|
||
|
||
for (tpls = conv; tpls; tpls = OVL_NEXT (tpls))
|
||
{
|
||
tree tpl = OVL_CURRENT (tpls);
|
||
tree type = DECL_CONV_FN_TYPE (tpl);
|
||
|
||
if (check_hidden_convs (binfo, virtual_depth, virtualness,
|
||
type, parent_tpl_convs, other_tpl_convs))
|
||
{
|
||
my_tpl_convs = tree_cons (binfo, tpl, my_tpl_convs);
|
||
TREE_TYPE (my_tpl_convs) = type;
|
||
if (virtual_depth)
|
||
{
|
||
TREE_STATIC (my_tpl_convs) = 1;
|
||
my_virtualness = 1;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
tree name = DECL_NAME (cur);
|
||
|
||
if (!IDENTIFIER_MARKED (name))
|
||
{
|
||
tree type = DECL_CONV_FN_TYPE (cur);
|
||
|
||
if (check_hidden_convs (binfo, virtual_depth, virtualness,
|
||
type, parent_convs, other_convs))
|
||
{
|
||
my_convs = tree_cons (binfo, conv, my_convs);
|
||
TREE_TYPE (my_convs) = type;
|
||
if (virtual_depth)
|
||
{
|
||
TREE_STATIC (my_convs) = 1;
|
||
my_virtualness = 1;
|
||
}
|
||
IDENTIFIER_MARKED (name) = 1;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (my_convs)
|
||
{
|
||
parent_convs = tree_cons (binfo, my_convs, parent_convs);
|
||
if (virtual_depth)
|
||
TREE_STATIC (parent_convs) = 1;
|
||
}
|
||
|
||
if (my_tpl_convs)
|
||
{
|
||
parent_tpl_convs = tree_cons (binfo, my_tpl_convs, parent_tpl_convs);
|
||
if (virtual_depth)
|
||
TREE_STATIC (parent_tpl_convs) = 1;
|
||
}
|
||
|
||
child_convs = other_convs;
|
||
child_tpl_convs = other_tpl_convs;
|
||
|
||
/* Now iterate over each base, looking for more conversions. */
|
||
for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
|
||
{
|
||
tree base_convs, base_tpl_convs;
|
||
unsigned base_virtualness;
|
||
|
||
base_virtualness = lookup_conversions_r (base_binfo,
|
||
virtual_depth, virtualness,
|
||
parent_convs, parent_tpl_convs,
|
||
child_convs, child_tpl_convs,
|
||
&base_convs, &base_tpl_convs);
|
||
if (base_virtualness)
|
||
my_virtualness = virtualness = 1;
|
||
child_convs = chainon (base_convs, child_convs);
|
||
child_tpl_convs = chainon (base_tpl_convs, child_tpl_convs);
|
||
}
|
||
|
||
/* Unmark the conversions found at this level */
|
||
for (conv = my_convs; conv; conv = TREE_CHAIN (conv))
|
||
IDENTIFIER_MARKED (DECL_NAME (OVL_CURRENT (TREE_VALUE (conv)))) = 0;
|
||
|
||
*convs = split_conversions (my_convs, parent_convs,
|
||
child_convs, other_convs);
|
||
*tpl_convs = split_conversions (my_tpl_convs, parent_tpl_convs,
|
||
child_tpl_convs, other_tpl_convs);
|
||
|
||
return my_virtualness;
|
||
}
|
||
|
||
/* Return a TREE_LIST containing all the non-hidden user-defined
|
||
conversion functions for TYPE (and its base-classes). The
|
||
TREE_VALUE of each node is the FUNCTION_DECL of the conversion
|
||
function. The TREE_PURPOSE is the BINFO from which the conversion
|
||
functions in this node were selected. This function is effectively
|
||
performing a set of member lookups as lookup_fnfield does, but
|
||
using the type being converted to as the unique key, rather than the
|
||
field name. */
|
||
|
||
tree
|
||
lookup_conversions (tree type)
|
||
{
|
||
tree convs, tpl_convs;
|
||
tree list = NULL_TREE;
|
||
|
||
complete_type (type);
|
||
if (!TYPE_BINFO (type))
|
||
return NULL_TREE;
|
||
|
||
lookup_conversions_r (TYPE_BINFO (type), 0, 0,
|
||
NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE,
|
||
&convs, &tpl_convs);
|
||
|
||
/* Flatten the list-of-lists */
|
||
for (; convs; convs = TREE_CHAIN (convs))
|
||
{
|
||
tree probe, next;
|
||
|
||
for (probe = TREE_VALUE (convs); probe; probe = next)
|
||
{
|
||
next = TREE_CHAIN (probe);
|
||
|
||
TREE_CHAIN (probe) = list;
|
||
list = probe;
|
||
}
|
||
}
|
||
|
||
for (; tpl_convs; tpl_convs = TREE_CHAIN (tpl_convs))
|
||
{
|
||
tree probe, next;
|
||
|
||
for (probe = TREE_VALUE (tpl_convs); probe; probe = next)
|
||
{
|
||
next = TREE_CHAIN (probe);
|
||
|
||
TREE_CHAIN (probe) = list;
|
||
list = probe;
|
||
}
|
||
}
|
||
|
||
return list;
|
||
}
|
||
|
||
/* Returns the binfo of the first direct or indirect virtual base derived
|
||
from BINFO, or NULL if binfo is not via virtual. */
|
||
|
||
tree
|
||
binfo_from_vbase (tree binfo)
|
||
{
|
||
for (; binfo; binfo = BINFO_INHERITANCE_CHAIN (binfo))
|
||
{
|
||
if (BINFO_VIRTUAL_P (binfo))
|
||
return binfo;
|
||
}
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* Returns the binfo of the first direct or indirect virtual base derived
|
||
from BINFO up to the TREE_TYPE, LIMIT, or NULL if binfo is not
|
||
via virtual. */
|
||
|
||
tree
|
||
binfo_via_virtual (tree binfo, tree limit)
|
||
{
|
||
if (limit && !CLASSTYPE_VBASECLASSES (limit))
|
||
/* LIMIT has no virtual bases, so BINFO cannot be via one. */
|
||
return NULL_TREE;
|
||
|
||
for (; binfo && !SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), limit);
|
||
binfo = BINFO_INHERITANCE_CHAIN (binfo))
|
||
{
|
||
if (BINFO_VIRTUAL_P (binfo))
|
||
return binfo;
|
||
}
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* BINFO is a base binfo in the complete type BINFO_TYPE (HERE).
|
||
Find the equivalent binfo within whatever graph HERE is located.
|
||
This is the inverse of original_binfo. */
|
||
|
||
tree
|
||
copied_binfo (tree binfo, tree here)
|
||
{
|
||
tree result = NULL_TREE;
|
||
|
||
if (BINFO_VIRTUAL_P (binfo))
|
||
{
|
||
tree t;
|
||
|
||
for (t = here; BINFO_INHERITANCE_CHAIN (t);
|
||
t = BINFO_INHERITANCE_CHAIN (t))
|
||
continue;
|
||
|
||
result = binfo_for_vbase (BINFO_TYPE (binfo), BINFO_TYPE (t));
|
||
}
|
||
else if (BINFO_INHERITANCE_CHAIN (binfo))
|
||
{
|
||
tree cbinfo;
|
||
tree base_binfo;
|
||
int ix;
|
||
|
||
cbinfo = copied_binfo (BINFO_INHERITANCE_CHAIN (binfo), here);
|
||
for (ix = 0; BINFO_BASE_ITERATE (cbinfo, ix, base_binfo); ix++)
|
||
if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo), BINFO_TYPE (binfo)))
|
||
{
|
||
result = base_binfo;
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (here), BINFO_TYPE (binfo)));
|
||
result = here;
|
||
}
|
||
|
||
gcc_assert (result);
|
||
return result;
|
||
}
|
||
|
||
tree
|
||
binfo_for_vbase (tree base, tree t)
|
||
{
|
||
unsigned ix;
|
||
tree binfo;
|
||
VEC(tree,gc) *vbases;
|
||
|
||
for (vbases = CLASSTYPE_VBASECLASSES (t), ix = 0;
|
||
VEC_iterate (tree, vbases, ix, binfo); ix++)
|
||
if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), base))
|
||
return binfo;
|
||
return NULL;
|
||
}
|
||
|
||
/* BINFO is some base binfo of HERE, within some other
|
||
hierarchy. Return the equivalent binfo, but in the hierarchy
|
||
dominated by HERE. This is the inverse of copied_binfo. If BINFO
|
||
is not a base binfo of HERE, returns NULL_TREE. */
|
||
|
||
tree
|
||
original_binfo (tree binfo, tree here)
|
||
{
|
||
tree result = NULL;
|
||
|
||
if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (here)))
|
||
result = here;
|
||
else if (BINFO_VIRTUAL_P (binfo))
|
||
result = (CLASSTYPE_VBASECLASSES (BINFO_TYPE (here))
|
||
? binfo_for_vbase (BINFO_TYPE (binfo), BINFO_TYPE (here))
|
||
: NULL_TREE);
|
||
else if (BINFO_INHERITANCE_CHAIN (binfo))
|
||
{
|
||
tree base_binfos;
|
||
|
||
base_binfos = original_binfo (BINFO_INHERITANCE_CHAIN (binfo), here);
|
||
if (base_binfos)
|
||
{
|
||
int ix;
|
||
tree base_binfo;
|
||
|
||
for (ix = 0; (base_binfo = BINFO_BASE_BINFO (base_binfos, ix)); ix++)
|
||
if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo),
|
||
BINFO_TYPE (binfo)))
|
||
{
|
||
result = base_binfo;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|