/* RunTime Type Identification
- Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000
+ Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001
Free Software Foundation, Inc.
Mostly written by Jason Merrill (jason@cygnus.com).
#include "assert.h"
#include "toplev.h"
-#ifndef INT_TYPE_SIZE
-#define INT_TYPE_SIZE BITS_PER_WORD
-#endif
-
/* Accessors for the type_info objects. We need to remember several things
about each of the type_info types. The global tree nodes such as
bltn_desc_type_node are TREE_LISTs, and these macros are used to access
extern struct obstack permanent_obstack;
-static tree build_headof_sub PARAMS((tree));
static tree build_headof PARAMS((tree));
-static tree get_tinfo_var PARAMS((tree));
static tree ifnonnull PARAMS((tree, tree));
static tree tinfo_name PARAMS((tree));
-static tree get_base_offset PARAMS((tree, tree));
static tree build_dynamic_cast_1 PARAMS((tree, tree));
-static void expand_si_desc PARAMS((tree, tree));
-static void expand_class_desc PARAMS((tree, tree));
-static void expand_attr_desc PARAMS((tree, tree));
-static void expand_ptr_desc PARAMS((tree, tree));
-static void expand_generic_desc PARAMS((tree, tree, const char *));
static tree throw_bad_cast PARAMS((void));
static tree throw_bad_typeid PARAMS((void));
static tree get_tinfo_decl_dynamic PARAMS((tree));
-static tree tinfo_from_decl PARAMS((tree));
+static bool typeid_ok_p PARAMS ((void));
static int qualifier_flags PARAMS((tree));
+static int target_incomplete_p PARAMS((tree));
static tree tinfo_base_init PARAMS((tree, tree));
static tree generic_initializer PARAMS((tree, tree));
-static tree ptr_initializer PARAMS((tree, tree));
-static tree ptmd_initializer PARAMS((tree, tree));
+static tree ptr_initializer PARAMS((tree, tree, int *));
+static tree ptm_initializer PARAMS((tree, tree, int *));
+static tree dfs_class_hint_mark PARAMS ((tree, void *));
+static tree dfs_class_hint_unmark PARAMS ((tree, void *));
static int class_hint_flags PARAMS((tree));
static tree class_initializer PARAMS((tree, tree, tree));
static tree synthesize_tinfo_var PARAMS((tree, tree));
-static tree create_real_tinfo_var PARAMS((tree, tree, tree));
+static tree create_real_tinfo_var PARAMS((tree, tree, tree, tree, int));
static tree create_pseudo_type_info PARAMS((const char *, int, ...));
static tree get_vmi_pseudo_type_info PARAMS((int));
static void create_tinfo_types PARAMS((void));
+static int typeinfo_in_lib_p PARAMS((tree));
static int doing_runtime = 0;
\f
void
init_rtti_processing ()
{
- if (flag_honor_std)
- push_namespace (get_identifier ("std"));
+ push_namespace (std_identifier);
type_info_type_node = xref_tag
(class_type_node, get_identifier ("type_info"), 1);
- if (flag_honor_std)
- pop_namespace ();
- if (!new_abi_rtti_p ())
- {
- tinfo_decl_id = get_identifier ("__tf");
- tinfo_decl_type = build_function_type
- (build_reference_type
- (build_qualified_type
- (type_info_type_node, TYPE_QUAL_CONST)),
- void_list_node);
- }
- else
- {
- tinfo_decl_id = get_identifier ("__ti");
- tinfo_decl_type = build_qualified_type
- (type_info_type_node, TYPE_QUAL_CONST);
- }
- tinfo_var_id = get_identifier ("__ti");
-}
-
-/* Given a pointer to an object with at least one virtual table
- pointer somewhere, return a pointer to a possible sub-object that
- has a virtual table pointer in it that is the vtable parent for
- that sub-object. */
-
-static tree
-build_headof_sub (exp)
- tree exp;
-{
- tree type = TREE_TYPE (TREE_TYPE (exp));
- tree basetype = CLASSTYPE_RTTI (type);
- tree binfo = get_binfo (basetype, type, 0);
-
- exp = convert_pointer_to_real (binfo, exp);
- return exp;
+ pop_namespace ();
+ tinfo_decl_type =
+ build_qualified_type (type_info_type_node, TYPE_QUAL_CONST);
}
/* Given the expression EXP of type `class *', return the head of the
tree exp;
{
tree type = TREE_TYPE (exp);
- tree aref;
tree offset;
+ tree index;
my_friendly_assert (TREE_CODE (type) == POINTER_TYPE, 20000112);
type = TREE_TYPE (type);
if (!TYPE_POLYMORPHIC_P (type))
return exp;
- if (CLASSTYPE_COM_INTERFACE (type))
- {
- cp_error ("RTTI not supported for COM interface type `%T'", type);
- return error_mark_node;
- }
-
- /* If we don't have rtti stuff, get to a sub-object that does. */
- if (!CLASSTYPE_VFIELDS (TREE_TYPE (TREE_TYPE (exp))))
- exp = build_headof_sub (exp);
/* We use this a couple of times below, protect it. */
exp = save_expr (exp);
- aref = build_vtbl_ref (build_indirect_ref (exp, NULL_PTR), integer_zero_node);
+ /* The offset-to-top field is at index -2 from the vptr. */
+ index = build_int_2 (-2, -1);
- if (flag_vtable_thunks)
- offset = aref;
- else
- offset = build_component_ref (aref, delta_identifier, NULL_TREE, 0);
+ offset = build_vtbl_ref (build_indirect_ref (exp, NULL), index);
type = build_qualified_type (ptr_type_node,
- CP_TYPE_QUALS (TREE_TYPE (exp)));
+ cp_type_quals (TREE_TYPE (exp)));
return build (PLUS_EXPR, type, exp,
cp_convert (ptrdiff_type_node, offset));
}
static tree
throw_bad_cast ()
{
- tree fn = get_identifier ("__throw_bad_cast");
+ tree fn = get_identifier ("__cxa_bad_cast");
if (IDENTIFIER_GLOBAL_VALUE (fn))
fn = IDENTIFIER_GLOBAL_VALUE (fn);
else
static tree
throw_bad_typeid ()
{
- tree fn = get_identifier ("__throw_bad_typeid");
+ tree fn = get_identifier ("__cxa_bad_typeid");
if (IDENTIFIER_GLOBAL_VALUE (fn))
fn = IDENTIFIER_GLOBAL_VALUE (fn);
else
/* Peel off cv qualifiers. */
type = TYPE_MAIN_VARIANT (type);
- if (type != void_type_node)
+ if (!VOID_TYPE_P (type))
type = complete_type_or_else (type, exp);
if (!type)
{
/* build reference to type_info from vtable. */
tree t;
+ tree index;
- if (! flag_rtti)
- error ("taking dynamic typeid of object with -fno-rtti");
- if (CLASSTYPE_COM_INTERFACE (type))
- {
- cp_error ("RTTI not supported for COM interface type `%T'", type);
- return error_mark_node;
- }
-
- /* If we don't have rtti stuff, get to a sub-object that does. */
- if (! CLASSTYPE_VFIELDS (type))
- {
- exp = build_unary_op (ADDR_EXPR, exp, 0);
- exp = build_headof_sub (exp);
- exp = build_indirect_ref (exp, NULL_PTR);
- }
-
- if (flag_vtable_thunks)
- t = build_vfn_ref ((tree *) 0, exp, integer_one_node);
- else
- t = build_vfn_ref ((tree *) 0, exp, integer_zero_node);
+ /* The RTTI information is at index -1. */
+ index = integer_minus_one_node;
+ t = build_vtbl_ref (exp, index);
TREE_TYPE (t) = build_pointer_type (tinfo_decl_type);
return t;
}
return build_unary_op (ADDR_EXPR, exp, 0);
}
-tree
-build_typeid (exp)
- tree exp;
+static bool
+typeid_ok_p ()
{
- tree cond = NULL_TREE;
- int nonnull = 0;
-
if (! flag_rtti)
{
error ("cannot use typeid with -fno-rtti");
- return error_mark_node;
+ return false;
}
if (!COMPLETE_TYPE_P (type_info_type_node))
{
error ("must #include <typeinfo> before using typeid");
- return error_mark_node;
+ return false;
}
+ return true;
+}
+
+tree
+build_typeid (exp)
+ tree exp;
+{
+ tree cond = NULL_TREE;
+ int nonnull = 0;
+
+ if (exp == error_mark_node || !typeid_ok_p ())
+ return error_mark_node;
+
if (processing_template_decl)
return build_min_nt (TYPEID_EXPR, exp);
if (exp == error_mark_node)
return error_mark_node;
- exp = tinfo_from_decl (exp);
+ exp = build_indirect_ref (exp, NULL);
if (cond)
{
return convert_from_reference (exp);
}
-static tree
-get_tinfo_var (type)
- tree type;
-{
- tree tname = build_overload_with_type (tinfo_var_id, type);
- tree arrtype;
- int size;
-
- my_friendly_assert (!new_abi_rtti_p (), 20000118);
- if (IDENTIFIER_GLOBAL_VALUE (tname))
- return IDENTIFIER_GLOBAL_VALUE (tname);
-
- /* Figure out how much space we need to allocate for the type_info object.
- If our struct layout or the type_info classes are changed, this will
- need to be modified. */
- if (TYPE_QUALS (type) != TYPE_UNQUALIFIED)
- size = 3 * POINTER_SIZE + INT_TYPE_SIZE;
- else if (TREE_CODE (type) == POINTER_TYPE
- && ! (TREE_CODE (TREE_TYPE (type)) == OFFSET_TYPE
- || TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE))
- size = 3 * POINTER_SIZE;
- else if (IS_AGGR_TYPE (type))
- {
- if (CLASSTYPE_N_BASECLASSES (type) == 0)
- size = 2 * POINTER_SIZE;
- else if (! TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type)
- && (TREE_VIA_PUBLIC
- (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), 0))))
- size = 3 * POINTER_SIZE;
- else
- size = 3 * POINTER_SIZE + TYPE_PRECISION (sizetype);
- }
- else
- size = 2 * POINTER_SIZE;
-
- /* The type for a character array of the appropriate size. */
- arrtype = build_cplus_array_type
- (unsigned_char_type_node,
- build_index_type (size_int (size / BITS_PER_UNIT - 1)));
-
- return declare_global_var (tname, arrtype);
-}
-
/* Generate the NTBS name of a type. */
static tree
tinfo_name (type)
tree type;
{
- const char *name = build_overload_name (type, 1, 1);
- tree name_string = combine_strings (build_string (strlen (name) + 1, name));
+ const char *name;
+ tree name_string;
+
+ name = mangle_type_string (type);
+ name_string = combine_strings (build_string (strlen (name) + 1, name));
return name_string;
}
-/* Returns a decl for a function or variable which can be used to obtain a
- type_info object for TYPE. The old-abi uses functions, the new-abi
- uses the type_info object directly. You can take the address of the
- returned decl, to save the decl. To use the decl call
- tinfo_from_decl. You must arrange that the decl is mark_used, if
- actually use it --- decls in vtables are only used if the vtable is
- output. */
+/* Returns a decl for the type_info variable for TYPE. You must
+ arrange that the decl is mark_used, if actually use it --- decls in
+ vtables are only used if the vtable is output. */
tree
get_tinfo_decl (type)
tree name;
tree d;
+ if (COMPLETE_TYPE_P (type)
+ && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
+ {
+ cp_error ("cannot create type information for type `%T' because its size is variable",
+ type);
+ return error_mark_node;
+ }
+
if (TREE_CODE (type) == OFFSET_TYPE)
type = TREE_TYPE (type);
if (TREE_CODE (type) == METHOD_TYPE)
type = build_function_type (TREE_TYPE (type),
TREE_CHAIN (TYPE_ARG_TYPES (type)));
- name = build_overload_with_type (tinfo_decl_id, type);
+ name = mangle_typeinfo_for_type (type);
d = IDENTIFIER_GLOBAL_VALUE (name);
if (d)
/* OK */;
- else if (!new_abi_rtti_p ())
- {
- /* The tinfo decl is a function returning a reference to the type_info
- object. */
- d = push_library_fn (name, tinfo_decl_type);
- DECL_NOT_REALLY_EXTERN (d) = 1;
- SET_DECL_TINFO_FN_P (d);
- TREE_TYPE (name) = type;
- mark_inline_for_output (d);
- }
else
{
/* The tinfo decl is the type_info object itself. We make all
tinfo objects look as type_info, even though they will end up
- being a subclass of that when emitted. This means the we'll
+ being a subclass of that when emitted. This means that we'll
erroneously think we know the dynamic type -- be careful in the
runtime. */
d = build_lang_decl (VAR_DECL, name, tinfo_decl_type);
DECL_ARTIFICIAL (d) = 1;
DECL_ALIGN (d) = TYPE_ALIGN (ptr_type_node);
+ DECL_USER_ALIGN (d) = 0;
TREE_READONLY (d) = 1;
TREE_STATIC (d) = 1;
DECL_EXTERNAL (d) = 1;
TREE_PUBLIC (d) = 1;
- DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
+ if (flag_weak || !typeinfo_in_lib_p (type))
+ comdat_linkage (d);
+ SET_DECL_ASSEMBLER_NAME (d, name);
cp_finish_decl (d, NULL_TREE, NULL_TREE, 0);
pushdecl_top_level (d);
/* Remember the type it is for. */
TREE_TYPE (name) = type;
+ TREE_USED (name) = 1;
}
return d;
}
-/* Given an expr produced by get_tinfo_decl, return an expr which
- produces a reference to the type_info object. */
-
-static tree
-tinfo_from_decl (expr)
- tree expr;
-{
- tree t;
-
- if (!new_abi_rtti_p ())
- t = build_call (expr, NULL_TREE);
- else if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
- t = build_indirect_ref (expr, NULL);
- else
- t = expr;
-
- return t;
-}
-
-tree
-get_typeid_1 (type)
- tree type;
-{
- tree t;
-
- t = get_tinfo_decl (type);
- t = tinfo_from_decl (t);
- return convert_from_reference (t);
-}
-
/* Return the type_info object for TYPE. */
tree
get_typeid (type)
tree type;
{
- if (type == error_mark_node)
+ if (type == error_mark_node || !typeid_ok_p ())
return error_mark_node;
-
- if (!COMPLETE_TYPE_P (type_info_type_node))
- {
- error ("must #include <typeinfo> before using typeid");
- return error_mark_node;
- }
if (processing_template_decl)
return build_min_nt (TYPEID_EXPR, type);
that is the operand of typeid are always ignored. */
type = TYPE_MAIN_VARIANT (type);
- if (type != void_type_node)
+ if (!VOID_TYPE_P (type))
type = complete_type_or_else (type, NULL_TREE);
if (!type)
return error_mark_node;
- return get_typeid_1 (type);
+ return get_tinfo_decl (type);
}
/* Check whether TEST is null before returning RESULT. If TEST is used in
result);
}
-/* Generate the constant expression describing where direct base BINFO
- appears within the PARENT. How to interpret this expression depends on
- details of the ABI, which the runtime must be aware of. */
-
-static tree
-get_base_offset (binfo, parent)
- tree binfo;
- tree parent;
-{
- tree offset;
-
- if (!TREE_VIA_VIRTUAL (binfo))
- offset = BINFO_OFFSET (binfo);
- else if (!vbase_offsets_in_vtable_p ())
- {
- tree t = BINFO_TYPE (binfo);
- const char *name;
- tree field;
-
- FORMAT_VBASE_NAME (name, t);
- field = lookup_field (parent, get_identifier (name), 0, 0);
- offset = size_binop (FLOOR_DIV_EXPR, bit_position (field),
- bitsize_int (BITS_PER_UNIT));
- offset = convert (sizetype, offset);
- }
- else
- {
- /* Under the new ABI, we store the vtable offset at which
- the virtual base offset can be found. */
- tree vbase = BINFO_FOR_VBASE (BINFO_TYPE (binfo), parent);
- offset = convert (sizetype, BINFO_VPTR_FIELD (vbase));
- }
- return offset;
-}
-
/* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
paper. */
tree type, expr;
{
enum tree_code tc = TREE_CODE (type);
- tree exprtype;
+ tree exprtype = TREE_TYPE (expr);
tree dcast_fn;
tree old_expr = expr;
- char* errstr = NULL;
+ const char *errstr = NULL;
/* T shall be a pointer or reference to a complete class type, or
`pointer to cv void''. */
}
if (TREE_CODE (expr) == OFFSET_REF)
- expr = resolve_offset_ref (expr);
-
- exprtype = TREE_TYPE (expr);
- assert (exprtype != NULL_TREE);
+ {
+ expr = resolve_offset_ref (expr);
+ exprtype = TREE_TYPE (expr);
+ }
if (tc == POINTER_TYPE)
expr = convert_from_reference (expr);
/* If *type is an unambiguous accessible base class of *exprtype,
convert statically. */
{
- int distance;
- tree path;
+ tree binfo;
- distance = get_base_distance (TREE_TYPE (type), TREE_TYPE (exprtype), 1,
- &path);
+ binfo = lookup_base (TREE_TYPE (exprtype), TREE_TYPE (type),
+ ba_not_special, NULL);
- if (distance == -2)
+ if (binfo)
{
- cp_error ("dynamic_cast from `%T' to ambiguous base class `%T'",
- TREE_TYPE (exprtype), TREE_TYPE (type));
- return error_mark_node;
+ expr = build_base_path (PLUS_EXPR, convert_from_reference (expr),
+ binfo, 0);
+ if (TREE_CODE (exprtype) == POINTER_TYPE)
+ expr = non_lvalue (expr);
+ return expr;
}
- if (distance == -3)
- {
- cp_error ("dynamic_cast from `%T' to private base class `%T'",
- TREE_TYPE (exprtype), TREE_TYPE (type));
- return error_mark_node;
- }
-
- if (distance >= 0)
- return build_vbase_path (PLUS_EXPR, type, expr, path, 0);
}
/* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
{
tree expr1;
/* if TYPE is `void *', return pointer to complete object. */
- if (tc == POINTER_TYPE
- && TYPE_MAIN_VARIANT (TREE_TYPE (type)) == void_type_node)
+ if (tc == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (type)))
{
/* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
if (TREE_CODE (expr) == ADDR_EXPR
if (tc == REFERENCE_TYPE)
expr1 = build_unary_op (ADDR_EXPR, expr1, 0);
- if (!new_abi_rtti_p ())
- {
- tree expr2 = build_headof (expr1);
- tree td1 = expr;
-
- if (tc == POINTER_TYPE)
- td1 = build_indirect_ref (td1, NULL_PTR);
- td1 = get_tinfo_decl_dynamic (td1);
-
- elems = tree_cons
- (NULL_TREE, td1, tree_cons
- (NULL_TREE, td2, tree_cons
- (NULL_TREE, boff, tree_cons
- (NULL_TREE, expr2, tree_cons
- (NULL_TREE, td3, tree_cons
- (NULL_TREE, expr1, NULL_TREE))))));
- }
- else
- elems = tree_cons
- (NULL_TREE, expr1, tree_cons
- (NULL_TREE, td3, tree_cons
- (NULL_TREE, td2, tree_cons
- (NULL_TREE, boff, NULL_TREE))));
+ elems = tree_cons
+ (NULL_TREE, expr1, tree_cons
+ (NULL_TREE, td3, tree_cons
+ (NULL_TREE, td2, tree_cons
+ (NULL_TREE, boff, NULL_TREE))));
dcast_fn = dynamic_cast_node;
if (!dcast_fn)
{
tree tmp;
tree tinfo_ptr;
- tree ns = new_abi_rtti_p () ? abi_node : global_namespace;
+ tree ns = abi_node;
const char *name;
push_nested_namespace (ns);
- if (!new_abi_rtti_p ())
- {
- tinfo_ptr = build_pointer_type (tinfo_decl_type);
- name = "__dynamic_cast_2";
- tmp = tree_cons
- (NULL_TREE, tinfo_ptr, tree_cons
- (NULL_TREE, tinfo_ptr, tree_cons
- (NULL_TREE, integer_type_node, tree_cons
- (NULL_TREE, ptr_type_node, tree_cons
- (NULL_TREE, tinfo_ptr, tree_cons
- (NULL_TREE, ptr_type_node, void_list_node))))));
- }
- else
- {
- tinfo_ptr = xref_tag (class_type_node,
- get_identifier ("__class_type_info"),
- 1);
-
- tinfo_ptr = build_pointer_type
- (build_qualified_type
- (tinfo_ptr, TYPE_QUAL_CONST));
- name = "__dynamic_cast";
- tmp = tree_cons
- (NULL_TREE, const_ptr_type_node, tree_cons
- (NULL_TREE, tinfo_ptr, tree_cons
- (NULL_TREE, tinfo_ptr, tree_cons
- (NULL_TREE, ptrdiff_type_node, void_list_node))));
- }
+ tinfo_ptr = xref_tag (class_type_node,
+ get_identifier ("__class_type_info"),
+ 1);
+
+ tinfo_ptr = build_pointer_type
+ (build_qualified_type
+ (tinfo_ptr, TYPE_QUAL_CONST));
+ name = "__dynamic_cast";
+ tmp = tree_cons
+ (NULL_TREE, const_ptr_type_node, tree_cons
+ (NULL_TREE, tinfo_ptr, tree_cons
+ (NULL_TREE, tinfo_ptr, tree_cons
+ (NULL_TREE, ptrdiff_type_node, void_list_node))));
tmp = build_function_type (ptr_type_node, tmp);
- if (new_abi_rtti_p ())
- /* We want its name mangling. */
- dcast_fn = build_cp_library_fn_ptr (name, tmp);
- else
- dcast_fn = build_library_fn_ptr (name, tmp);
+ dcast_fn = build_library_fn_ptr (name, tmp);
pop_nested_namespace (ns);
dynamic_cast_node = dcast_fn;
}
return convert_from_reference (build_dynamic_cast_1 (type, expr));
}
\f
-/* Build and initialize various sorts of descriptors. Every descriptor
- node has a name associated with it (the name created by mangling).
- For this reason, we use the identifier as our access to the __*_desc
- nodes, instead of sticking them directly in the types. Otherwise we
- would burden all built-in types (and pointer types) with slots that
- we don't necessarily want to use.
-
- For each descriptor we build, we build a variable that contains
- the descriptor's information. When we need this info at runtime,
- all we need is access to these variables.
-
- Note: these constructors always return the address of the descriptor
- info, since that is simplest for their mutual interaction. */
-
-/* Build an initializer for a __si_type_info node. */
-
-static void
-expand_si_desc (tdecl, type)
- tree tdecl;
- tree type;
-{
- tree t, elems, fn;
- tree name_string = tinfo_name (type);
-
- type = BINFO_TYPE (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), 0));
- finish_expr_stmt (get_typeid_1 (type));
- t = decay_conversion (get_tinfo_var (type));
- elems = tree_cons
- (NULL_TREE, decay_conversion (tdecl), tree_cons
- (NULL_TREE, decay_conversion (name_string), tree_cons
- (NULL_TREE, t, NULL_TREE)));
-
- fn = get_identifier ("__rtti_si");
- if (IDENTIFIER_GLOBAL_VALUE (fn))
- fn = IDENTIFIER_GLOBAL_VALUE (fn);
- else
- {
- tree tmp;
- tmp = tree_cons
- (NULL_TREE, ptr_type_node, tree_cons
- (NULL_TREE, const_string_type_node, tree_cons
- (NULL_TREE, build_pointer_type (type_info_type_node),
- void_list_node)));
- fn = push_void_library_fn (fn, tmp);
- }
-
- fn = build_call (fn, elems);
- finish_expr_stmt (fn);
-}
-
-/* Build an initializer for a __class_type_info node. */
-
-static void
-expand_class_desc (tdecl, type)
- tree tdecl;
- tree type;
-{
- tree name_string;
- tree fn, tmp;
-
- int i = CLASSTYPE_N_BASECLASSES (type);
- int base_cnt = 0;
- tree binfos = TYPE_BINFO_BASETYPES (type);
-#if 0
- /* See code below that used these. */
- tree vb = CLASSTYPE_VBASECLASSES (type);
- int n_base = i;
-#endif
- tree base, elems, access, offset, isvir;
- tree elt, elts = NULL_TREE;
-
- if (base_desc_type_node == NULL_TREE)
- {
- tree fields [4];
-
- /* A reasonably close approximation of __class_type_info::base_info */
-
- base_desc_type_node = make_aggr_type (RECORD_TYPE);
-
- /* Actually const __user_type_info * */
- fields [0] = build_lang_decl
- (FIELD_DECL, NULL_TREE,
- build_pointer_type (build_qualified_type
- (type_info_type_node,
- TYPE_QUAL_CONST)));
- fields [1] = build_lang_decl
- (FIELD_DECL, NULL_TREE,
- flag_new_abi ? intSI_type_node : unsigned_intSI_type_node);
- DECL_BIT_FIELD (fields[1]) = 1;
- DECL_SIZE (fields[1]) = bitsize_int (29);
-
- fields [2] = build_lang_decl (FIELD_DECL, NULL_TREE, boolean_type_node);
- DECL_BIT_FIELD (fields[2]) = 1;
- DECL_SIZE (fields[2]) = bitsize_int (1);
-
- /* Actually enum access */
- fields [3] = build_lang_decl (FIELD_DECL, NULL_TREE, integer_type_node);
- DECL_BIT_FIELD (fields[3]) = 1;
- DECL_SIZE (fields[3]) = bitsize_int (2);
-
- finish_builtin_type (base_desc_type_node, "__base_info", fields,
- 3, ptr_type_node);
- }
-
- while (--i >= 0)
- {
- tree binfo = TREE_VEC_ELT (binfos, i);
-
- finish_expr_stmt (get_typeid_1 (BINFO_TYPE (binfo)));
- base = decay_conversion (get_tinfo_var (BINFO_TYPE (binfo)));
- offset = get_base_offset (binfo, type);
-
- if (TREE_VIA_PUBLIC (binfo))
- access = access_public_node;
- else if (TREE_VIA_PROTECTED (binfo))
- access = access_protected_node;
- else
- access = access_private_node;
- if (TREE_VIA_VIRTUAL (binfo))
- isvir = boolean_true_node;
- else
- isvir = boolean_false_node;
-
- elt = build
- (CONSTRUCTOR, base_desc_type_node, NULL_TREE, tree_cons
- (NULL_TREE, base, tree_cons
- (NULL_TREE, offset, tree_cons
- (NULL_TREE, isvir, tree_cons
- (NULL_TREE, access, NULL_TREE)))));
- TREE_HAS_CONSTRUCTOR (elt) = TREE_CONSTANT (elt) = TREE_STATIC (elt) = 1;
- elts = tree_cons (NULL_TREE, elt, elts);
- base_cnt++;
- }
-#if 0
- i = n_base;
- while (vb)
- {
- tree b;
- access = access_public_node;
- while (--i >= 0)
- {
- b = TREE_VEC_ELT (binfos, i);
- if (BINFO_TYPE (vb) == BINFO_TYPE (b) && TREE_VIA_VIRTUAL (b))
- {
- if (TREE_VIA_PUBLIC (b))
- access = access_public_node;
- else if (TREE_VIA_PROTECTED (b))
- access = access_protected_node;
- else
- access = access_private_node;
- break;
- }
- }
- base = build_t_desc (BINFO_TYPE (vb), 1);
- offset = BINFO_OFFSET (vb);
- isvir = build_int_2 (1, 0);
-
- base_list = tree_cons (NULL_TREE, base, base_list);
- isvir_list = tree_cons (NULL_TREE, isvir, isvir_list);
- acc_list = tree_cons (NULL_TREE, access, acc_list);
- off_list = tree_cons (NULL_TREE, offset, off_list);
-
- base_cnt++;
- vb = TREE_CHAIN (vb);
- }
-#endif
-
- name_string = tinfo_name (type);
-
- {
- tree arrtype = build_array_type (base_desc_type_node, NULL_TREE);
- elts = build (CONSTRUCTOR, arrtype, NULL_TREE, elts);
- TREE_HAS_CONSTRUCTOR (elts) = TREE_CONSTANT (elts)
- = TREE_STATIC (elts) = 1;
- complete_array_type (arrtype, elts, 1);
- }
-
- elems = tree_cons
- (NULL_TREE, decay_conversion (tdecl), tree_cons
- (NULL_TREE, decay_conversion (name_string), tree_cons
- (NULL_TREE, decay_conversion (elts), tree_cons
- (NULL_TREE, cp_convert (sizetype, build_int_2 (base_cnt, 0)),
- NULL_TREE))));
-
- fn = get_identifier ("__rtti_class");
- if (IDENTIFIER_GLOBAL_VALUE (fn))
- fn = IDENTIFIER_GLOBAL_VALUE (fn);
- else
- {
- tmp = tree_cons
- (NULL_TREE, ptr_type_node, tree_cons
- (NULL_TREE, const_string_type_node, tree_cons
- (NULL_TREE, build_pointer_type (base_desc_type_node), tree_cons
- (NULL_TREE, sizetype, void_list_node))));
-
- fn = push_void_library_fn (fn, tmp);
- }
-
- fn = build_call (fn, elems);
- finish_expr_stmt (fn);
-}
-
-/* Build an initializer for a __pointer_type_info node. */
-
-static void
-expand_ptr_desc (tdecl, type)
- tree tdecl;
- tree type;
-{
- tree t, elems, fn;
- tree name_string = tinfo_name (type);
-
- type = TREE_TYPE (type);
- finish_expr_stmt (get_typeid_1 (type));
- t = decay_conversion (get_tinfo_var (type));
- elems = tree_cons
- (NULL_TREE, decay_conversion (tdecl), tree_cons
- (NULL_TREE, decay_conversion (name_string), tree_cons
- (NULL_TREE, t, NULL_TREE)));
-
- fn = get_identifier ("__rtti_ptr");
- if (IDENTIFIER_GLOBAL_VALUE (fn))
- fn = IDENTIFIER_GLOBAL_VALUE (fn);
- else
- {
- tree tmp;
- tmp = tree_cons
- (NULL_TREE, ptr_type_node, tree_cons
- (NULL_TREE, const_string_type_node, tree_cons
- (NULL_TREE, build_pointer_type (type_info_type_node),
- void_list_node)));
- fn = push_void_library_fn (fn, tmp);
- }
-
- fn = build_call (fn, elems);
- finish_expr_stmt (fn);
-}
-
-/* Build an initializer for a __attr_type_info node. */
-
-static void
-expand_attr_desc (tdecl, type)
- tree tdecl;
- tree type;
-{
- tree elems, t, fn;
- tree name_string = tinfo_name (type);
- tree attrval = build_int_2 (TYPE_QUALS (type), 0);
-
- finish_expr_stmt (get_typeid_1 (TYPE_MAIN_VARIANT (type)));
- t = decay_conversion (get_tinfo_var (TYPE_MAIN_VARIANT (type)));
- elems = tree_cons
- (NULL_TREE, decay_conversion (tdecl), tree_cons
- (NULL_TREE, decay_conversion (name_string), tree_cons
- (NULL_TREE, attrval, tree_cons (NULL_TREE, t, NULL_TREE))));
-
- fn = get_identifier ("__rtti_attr");
- if (IDENTIFIER_GLOBAL_VALUE (fn))
- fn = IDENTIFIER_GLOBAL_VALUE (fn);
- else
- {
- tree tmp;
- tmp = tree_cons
- (NULL_TREE, ptr_type_node, tree_cons
- (NULL_TREE, const_string_type_node, tree_cons
- (NULL_TREE, integer_type_node, tree_cons
- (NULL_TREE, build_pointer_type (type_info_type_node),
- void_list_node))));
- fn = push_void_library_fn (fn, tmp);
- }
-
- fn = build_call (fn, elems);
- finish_expr_stmt (fn);
-}
-
-/* Build an initializer for a type_info node that just has a name. */
-
-static void
-expand_generic_desc (tdecl, type, fnname)
- tree tdecl;
- tree type;
- const char *fnname;
-{
- tree name_string = tinfo_name (type);
- tree elems = tree_cons
- (NULL_TREE, decay_conversion (tdecl), tree_cons
- (NULL_TREE, decay_conversion (name_string), NULL_TREE));
-
- tree fn = get_identifier (fnname);
- if (IDENTIFIER_GLOBAL_VALUE (fn))
- fn = IDENTIFIER_GLOBAL_VALUE (fn);
- else
- {
- tree tmp;
- tmp = tree_cons
- (NULL_TREE, ptr_type_node, tree_cons
- (NULL_TREE, const_string_type_node, void_list_node));
- fn = push_void_library_fn (fn, tmp);
- }
-
- fn = build_call (fn, elems);
- finish_expr_stmt (fn);
-}
-
-/* Generate the code for a type_info initialization function.
- Note that we take advantage of the passage
-
- 5.2.7 Type identification [expr.typeid]
-
- Whether or not the destructor is called for the type_info object at the
- end of the program is unspecified.
-
- and don't bother to arrange for these objects to be destroyed. It
- doesn't matter, anyway, since the destructors don't do anything.
-
- This must only be called from toplevel (i.e. from finish_file)! */
-
-void
-synthesize_tinfo_fn (fndecl)
- tree fndecl;
-{
- tree type = TREE_TYPE (DECL_NAME (fndecl));
- tree tmp, addr, tdecl;
- tree compound_stmt;
- tree if_stmt;
- tree then_clause;
-
- my_friendly_assert (!new_abi_rtti_p (), 20000118);
- if (at_eof)
- {
- import_export_decl (fndecl);
- if (DECL_REALLY_EXTERN (fndecl))
- return;
- }
-
- /* Declare the static typeinfo variable. */
- tdecl = get_tinfo_var (type);
- DECL_EXTERNAL (tdecl) = 0;
- TREE_STATIC (tdecl) = 1;
- DECL_COMMON (tdecl) = 1;
- TREE_USED (tdecl) = 1;
- DECL_ALIGN (tdecl) = TYPE_ALIGN (ptr_type_node);
- cp_finish_decl (tdecl, NULL_TREE, NULL_TREE, 0);
-
- /* Begin processing the function. */
- start_function (NULL_TREE, fndecl, NULL_TREE,
- SF_DEFAULT | SF_PRE_PARSED);
- DECL_DEFER_OUTPUT (fndecl) = 1;
- store_parm_decls ();
- clear_last_expr ();
-
- /* Begin the body of the function. */
- compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
-
- /* For convenience, we save away the address of the static
- variable. */
- addr = decay_conversion (tdecl);
-
- /* If the first word of the array (the vtable) is non-zero, we've already
- initialized the object, so don't do it again. */
- if_stmt = begin_if_stmt ();
- tmp = cp_convert (build_pointer_type (ptr_type_node), addr);
- tmp = build_indirect_ref (tmp, 0);
- tmp = build_binary_op (EQ_EXPR, tmp, integer_zero_node);
- finish_if_stmt_cond (tmp, if_stmt);
- then_clause = begin_compound_stmt (/*has_no_scope=*/0);
-
- if (TREE_CODE (type) == FUNCTION_TYPE)
- expand_generic_desc (tdecl, type, "__rtti_func");
- else if (TREE_CODE (type) == ARRAY_TYPE)
- expand_generic_desc (tdecl, type, "__rtti_array");
- else if (TYPE_QUALS (type) != TYPE_UNQUALIFIED)
- expand_attr_desc (tdecl, type);
- else if (TREE_CODE (type) == POINTER_TYPE)
- {
- if (TREE_CODE (TREE_TYPE (type)) == OFFSET_TYPE)
- expand_generic_desc (tdecl, type, "__rtti_ptmd");
- else if (TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)
- expand_generic_desc (tdecl, type, "__rtti_ptmf");
- else
- expand_ptr_desc (tdecl, type);
- }
- else if (TYPE_PTRMEMFUNC_P (type))
- expand_generic_desc (tdecl, type, "__rtti_ptmf");
- else if (IS_AGGR_TYPE (type))
- {
- if (CLASSTYPE_N_BASECLASSES (type) == 0)
- expand_generic_desc (tdecl, type, "__rtti_user");
- else if (! TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type)
- && (TREE_VIA_PUBLIC
- (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), 0))))
- expand_si_desc (tdecl, type);
- else
- expand_class_desc (tdecl, type);
- }
- else if (TREE_CODE (type) == ENUMERAL_TYPE)
- expand_generic_desc (tdecl, type, "__rtti_user");
- else
- my_friendly_abort (252);
-
- finish_compound_stmt (/*has_no_scope=*/0, then_clause);
- finish_then_clause (if_stmt);
- finish_if_stmt ();
-
- /* OK, now return the type_info object. */
- tmp = cp_convert (build_pointer_type (type_info_type_node), addr);
- tmp = build_indirect_ref (tmp, 0);
- finish_return_stmt (tmp);
- /* Finish the function body. */
- finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
- expand_body (finish_function (lineno, 0));
-}
-
/* Return the runtime bit mask encoding the qualifiers of TYPE. */
static int
flags |= 1;
if (quals & TYPE_QUAL_VOLATILE)
flags |= 2;
+ if (quals & TYPE_QUAL_RESTRICT)
+ flags |= 4;
return flags;
}
+/* Return non-zero, if the pointer chain TYPE ends at an incomplete type, or
+ contains a pointer to member of an incomplete class. */
+
+static int
+target_incomplete_p (type)
+ tree type;
+{
+ while (TREE_CODE (type) == POINTER_TYPE)
+ if (TYPE_PTRMEM_P (type))
+ {
+ if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type)))
+ return 1;
+ type = TYPE_PTRMEM_POINTED_TO_TYPE (type);
+ }
+ else
+ type = TREE_TYPE (type);
+ if (!COMPLETE_OR_VOID_TYPE_P (type))
+ return 1;
+
+ return 0;
+}
+
/* Return a CONSTRUCTOR for the common part of the type_info objects. This
- is the vtable pointer and NTBS name. */
+ is the vtable pointer and NTBS name. The NTBS name is emitted as a
+ comdat const char array, so it becomes a unique key for the type. Generate
+ and emit that VAR_DECL here. (We can't always emit the type_info itself
+ as comdat, because of pointers to incomplete.) */
static tree
tinfo_base_init (desc, target)
tree desc;
tree target;
{
- tree name_string = tinfo_name (target);
tree init = NULL_TREE;
+ tree name_decl;
+
+ {
+ tree name_name;
+
+ /* Generate the NTBS array variable. */
+ tree name_type = build_cplus_array_type
+ (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
+ NULL_TREE);
+ tree name_string = tinfo_name (target);
+
+ name_name = mangle_typeinfo_string_for_type (target);
+ name_decl = build_lang_decl (VAR_DECL, name_name, name_type);
+
+ DECL_ARTIFICIAL (name_decl) = 1;
+ TREE_READONLY (name_decl) = 1;
+ TREE_STATIC (name_decl) = 1;
+ DECL_EXTERNAL (name_decl) = 0;
+ TREE_PUBLIC (name_decl) = 1;
+ comdat_linkage (name_decl);
+ /* External name of the string containing the type's name has a
+ special name. */
+ SET_DECL_ASSEMBLER_NAME (name_decl,
+ mangle_typeinfo_string_for_type (target));
+ DECL_INITIAL (name_decl) = name_string;
+ cp_finish_decl (name_decl, name_string, NULL_TREE, 0);
+ pushdecl_top_level (name_decl);
+ }
if (TINFO_VTABLE_DECL (desc))
{
- tree vtbl_ptr = build_unary_op (ADDR_EXPR, TINFO_VTABLE_DECL (desc), 0);
-
+ tree vtbl_ptr = TINFO_VTABLE_DECL (desc);
init = tree_cons (NULL_TREE, vtbl_ptr, init);
}
- init = tree_cons (NULL_TREE, decay_conversion (name_string), init);
+ init = tree_cons (NULL_TREE, decay_conversion (name_decl), init);
init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, nreverse (init));
TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
which adds target type and qualifier flags members to the type_info base. */
static tree
-ptr_initializer (desc, target)
+ptr_initializer (desc, target, non_public_ptr)
tree desc;
tree target;
+ int *non_public_ptr;
{
tree init = tinfo_base_init (desc, target);
tree to = TREE_TYPE (target);
int flags = qualifier_flags (to);
+ int incomplete = target_incomplete_p (to);
+ if (incomplete)
+ {
+ flags |= 8;
+ *non_public_ptr = 1;
+ }
init = tree_cons (NULL_TREE, build_int_2 (flags, 0), init);
init = tree_cons (NULL_TREE,
build_unary_op (ADDR_EXPR,
/* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
DESC provides information about the particular type_info derivation,
- which adds target type and qualifier flags members to the type_info base. */
+ which adds class, target type and qualifier flags members to the type_info
+ base. */
static tree
-ptmd_initializer (desc, target)
+ptm_initializer (desc, target, non_public_ptr)
tree desc;
tree target;
+ int *non_public_ptr;
{
tree init = tinfo_base_init (desc, target);
tree to = TYPE_PTRMEM_POINTED_TO_TYPE (target);
tree klass = TYPE_PTRMEM_CLASS_TYPE (target);
int flags = qualifier_flags (to);
+ int incomplete = target_incomplete_p (to);
- init = tree_cons (NULL_TREE,
- build_unary_op (ADDR_EXPR, get_tinfo_decl (klass), 0),
- init);
+ if (incomplete)
+ {
+ flags |= 0x8;
+ *non_public_ptr = 1;
+ }
+ if (!COMPLETE_TYPE_P (klass))
+ {
+ flags |= 0x10;
+ *non_public_ptr = 1;
+ }
+ init = tree_cons (NULL_TREE, build_int_2 (flags, 0), init);
init = tree_cons (NULL_TREE,
build_unary_op (ADDR_EXPR,
get_tinfo_decl (TYPE_MAIN_VARIANT (to)), 0),
init);
- init = tree_cons (NULL_TREE, build_int_2 (flags, 0), init);
+ init = tree_cons (NULL_TREE,
+ build_unary_op (ADDR_EXPR, get_tinfo_decl (klass), 0),
+ init);
init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, nreverse (init));
TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
return init;
}
-/* Determine the hint flags describing the features of a class's heirarchy.
- FIXME: better set the hint_flags here! For now set them
- to safe 'don't know' values. The specification is under
- review. Don't forget to check the runtime dynamic_cast and
- catch machinery if these change. */
+/* Check base BINFO to set hint flags in *DATA, which is really an int.
+ We use CLASSTYPE_MARKED to tag types we've found as non-virtual bases and
+ CLASSTYPE_MARKED2 to tag those which are virtual bases. Remember it is
+ possible for a type to be both a virtual and non-virtual base. */
+
+static tree
+dfs_class_hint_mark (binfo, data)
+ tree binfo;
+ void *data;
+{
+ tree basetype = BINFO_TYPE (binfo);
+ int *hint = (int *) data;
+
+ if (TREE_VIA_VIRTUAL (binfo))
+ {
+ if (CLASSTYPE_MARKED (basetype))
+ *hint |= 1;
+ if (CLASSTYPE_MARKED2 (basetype))
+ *hint |= 2;
+ SET_CLASSTYPE_MARKED2 (basetype);
+ }
+ else
+ {
+ if (CLASSTYPE_MARKED (basetype) || CLASSTYPE_MARKED2 (basetype))
+ *hint |= 1;
+ SET_CLASSTYPE_MARKED (basetype);
+ }
+ if (!TREE_VIA_PUBLIC (binfo) && TYPE_BINFO (basetype) != binfo)
+ *hint |= 4;
+ return NULL_TREE;
+};
+
+/* Clear the base's dfs marks, after searching for duplicate bases. */
+
+static tree
+dfs_class_hint_unmark (binfo, data)
+ tree binfo;
+ void *data ATTRIBUTE_UNUSED;
+{
+ tree basetype = BINFO_TYPE (binfo);
+
+ CLEAR_CLASSTYPE_MARKED (basetype);
+ CLEAR_CLASSTYPE_MARKED2 (basetype);
+ return NULL_TREE;
+}
+
+/* Determine the hint flags describing the features of a class's heirarchy. */
static int
class_hint_flags (type)
tree type;
{
int hint_flags = 0;
- hint_flags |= 0x1; /* contains multiply inherited sub object */
- hint_flags |= 0x4; /* has virtual bases */
- hint_flags |= 0x8; /* has private base */
- if (TYPE_POLYMORPHIC_P (type))
- hint_flags |= 0x2;
+ int i;
+
+ dfs_walk (TYPE_BINFO (type), dfs_class_hint_mark, NULL, &hint_flags);
+ dfs_walk (TYPE_BINFO (type), dfs_class_hint_unmark, NULL, NULL);
+ for (i = 0; i < CLASSTYPE_N_BASECLASSES (type); ++i)
+ {
+ tree base_binfo = BINFO_BASETYPE (TYPE_BINFO (type), i);
+
+ if (TREE_VIA_PUBLIC (base_binfo))
+ hint_flags |= 0x8;
+ }
return hint_flags;
}
tree trail;
{
tree init = tinfo_base_init (desc, target);
- int flags = class_hint_flags (target);
- trail = tree_cons (NULL_TREE, build_int_2 (flags, 0), trail);
TREE_CHAIN (init) = trail;
init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, init);
TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
return init;
}
+/* Returns non-zero if the typeinfo for type should be placed in
+ the runtime library. */
+
+static int
+typeinfo_in_lib_p (type)
+ tree type;
+{
+ /* The typeinfo objects for `T*' and `const T*' are in the runtime
+ library for simple types T. */
+ if (TREE_CODE (type) == POINTER_TYPE
+ && (cp_type_quals (TREE_TYPE (type)) == TYPE_QUAL_CONST
+ || cp_type_quals (TREE_TYPE (type)) == TYPE_UNQUALIFIED))
+ type = TREE_TYPE (type);
+
+ switch (TREE_CODE (type))
+ {
+ case INTEGER_TYPE:
+ case BOOLEAN_TYPE:
+ case CHAR_TYPE:
+ case REAL_TYPE:
+ case VOID_TYPE:
+ return 1;
+
+ default:
+ return 0;
+ }
+}
+
/* Generate a pseudo_type_info VAR_DECL suitable for the supplied
TARGET_TYPE and given the REAL_NAME. This is the structure expected by
the runtime, and therefore has additional fields. If we need not emit a
{
tree var_init = NULL_TREE;
tree var_type = NULL_TREE;
+ int non_public = 0;
- my_friendly_assert (new_abi_rtti_p (), 20000118);
-
switch (TREE_CODE (target_type))
{
case POINTER_TYPE:
if (TYPE_PTRMEM_P (target_type))
{
- var_type = ptmd_desc_type_node;
- var_init = ptmd_initializer (var_type, target_type);
+ var_type = ptm_desc_type_node;
+ var_init = ptm_initializer (var_type, target_type, &non_public);
}
else
{
- int code = TREE_CODE (TREE_TYPE (target_type));
-
- if ((CP_TYPE_QUALS (TREE_TYPE (target_type)) | TYPE_QUAL_CONST)
- == TYPE_QUAL_CONST
- && (code == INTEGER_TYPE || code == BOOLEAN_TYPE
- || code == CHAR_TYPE || code == REAL_TYPE
- || code == VOID_TYPE)
- && !doing_runtime)
+ if (typeinfo_in_lib_p (target_type) && !doing_runtime)
/* These are in the runtime. */
return NULL_TREE;
var_type = ptr_desc_type_node;
- var_init = ptr_initializer (var_type, target_type);
+ var_init = ptr_initializer (var_type, target_type, &non_public);
}
break;
case ENUMERAL_TYPE:
break;
case UNION_TYPE:
case RECORD_TYPE:
- if (!COMPLETE_TYPE_P (target_type))
+ if (TYPE_PTRMEMFUNC_P (target_type))
{
- /* FIXME: incomplete type. Awaiting specification. */
- return NULL_TREE;
+ var_type = ptm_desc_type_node;
+ var_init = ptm_initializer (var_type, target_type, &non_public);
+ }
+ else if (!COMPLETE_TYPE_P (target_type))
+ {
+ /* Emit a non-public class_type_info. */
+ non_public = 1;
+ var_type = class_desc_type_node;
+ var_init = class_initializer (var_type, target_type, NULL_TREE);
}
else if (!CLASSTYPE_N_BASECLASSES (target_type))
{
tree tinfo;
tree offset;
- if (TREE_VIA_VIRTUAL (base_binfo))
- flags |= 1;
if (TREE_PUBLIC (base_binfo))
flags |= 2;
tinfo = get_tinfo_decl (BINFO_TYPE (base_binfo));
tinfo = build_unary_op (ADDR_EXPR, tinfo, 0);
- offset = get_base_offset (base_binfo, target_type);
+ if (TREE_VIA_VIRTUAL (base_binfo))
+ {
+ /* We store the vtable offset at which the virtual
+ base offset can be found. */
+ offset = BINFO_VPTR_FIELD (binfo_for_vbase (BINFO_TYPE (base_binfo),
+ target_type));
+ offset = convert (sizetype, offset);
+ flags |= 1;
+ }
+ else
+ offset = BINFO_OFFSET (base_binfo);
/* is it a single public inheritance? */
if (is_simple && flags == 2 && integer_zerop (offset))
}
is_simple = 0;
- base_init = tree_cons
- (NULL_TREE, build_int_2 (flags, 0), base_init);
+ /* combine offset and flags into one field */
+ offset = cp_build_binary_op (LSHIFT_EXPR, offset,
+ build_int_2 (8, 0));
+ offset = cp_build_binary_op (BIT_IOR_EXPR, offset,
+ build_int_2 (flags, 0));
base_init = tree_cons (NULL_TREE, offset, base_init);
base_init = tree_cons (NULL_TREE, tinfo, base_init);
base_init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, base_init);
var_type = si_class_desc_type_node;
else
{
- /* Prepend the number of bases. */
+ int hint = class_hint_flags (target_type);
+
base_inits = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, base_inits);
base_inits = tree_cons (NULL_TREE, base_inits, NULL_TREE);
+ /* Prepend the number of bases. */
base_inits = tree_cons (NULL_TREE,
build_int_2 (nbases, 0), base_inits);
-
+ /* Prepend the hint flags. */
+ base_inits = tree_cons (NULL_TREE,
+ build_int_2 (hint, 0), base_inits);
var_type = get_vmi_pseudo_type_info (nbases);
}
var_init = class_initializer (var_type, target_type, base_inits);
}
break;
- case INTEGER_TYPE:
- case BOOLEAN_TYPE:
- case CHAR_TYPE:
- case REAL_TYPE:
- case VOID_TYPE:
- if (!doing_runtime)
- /* These are guaranteed to be in the runtime. */
- return NULL_TREE;
- var_type = bltn_desc_type_node;
- var_init = generic_initializer (var_type, target_type);
- break;
+
default:
+ if (typeinfo_in_lib_p (target_type))
+ {
+ if (!doing_runtime)
+ /* These are guaranteed to be in the runtime. */
+ return NULL_TREE;
+ var_type = bltn_desc_type_node;
+ var_init = generic_initializer (var_type, target_type);
+ break;
+ }
my_friendly_abort (20000117);
}
- return create_real_tinfo_var (real_name, TINFO_PSEUDO_TYPE (var_type), var_init);
+ return create_real_tinfo_var (target_type,
+ real_name, TINFO_PSEUDO_TYPE (var_type),
+ var_init, non_public);
}
-/* Create the real typeinfo variable. */
+/* Create the real typeinfo variable. NON_PUBLIC indicates that we cannot
+ make this variable public (comdat). */
static tree
-create_real_tinfo_var (name, type, init)
+create_real_tinfo_var (target_type, name, type, init, non_public)
+ tree target_type;
tree name;
tree type;
tree init;
+ int non_public;
{
+ static int count = 0;
tree decl;
+ tree hidden_name;
+ char hidden[30];
+
+ /* We cannot give this the name NAME, as that already is globally
+ bound to the tinfo_decl we originally created for this type in
+ get_tinfo_decl. */
+ sprintf (hidden, "__ti_%d", count++);
+ hidden_name = get_identifier (hidden);
- decl = build_lang_decl (VAR_DECL, name,
+ decl = build_lang_decl (VAR_DECL, hidden_name,
build_qualified_type (type, TYPE_QUAL_CONST));
DECL_ARTIFICIAL (decl) = 1;
TREE_READONLY (decl) = 1;
TREE_STATIC (decl) = 1;
- TREE_PUBLIC (decl) = 1;
DECL_EXTERNAL (decl) = 0;
- comdat_linkage (decl);
- DECL_ASSEMBLER_NAME (decl) = name;
+ if (!non_public)
+ {
+ TREE_PUBLIC (decl) = 1;
+ if (flag_weak || !typeinfo_in_lib_p (target_type))
+ comdat_linkage (decl);
+ }
+ SET_DECL_ASSEMBLER_NAME (decl, name);
DECL_INITIAL (decl) = init;
cp_finish_decl (decl, init, NULL_TREE, 0);
-
+ pushdecl_top_level (decl);
+ TREE_USED (decl) = 1;
return decl;
}
static tree
create_pseudo_type_info VPARAMS((const char *real_name, int ident, ...))
{
-#ifndef ANSI_PROTOTYPES
- char const *real_name;
- int ident;
-#endif
- va_list ap;
tree real_type, pseudo_type;
char *pseudo_name;
tree vtable_decl;
tree fields[10];
tree field_decl;
tree result;
-
- VA_START (ap, ident);
-#ifndef ANSI_PROTOTYPES
- real_name = va_arg (ap, char const *);
- ident = va_arg (app, int);
-#endif
+
+ VA_OPEN (ap, ident);
+ VA_FIXEDARG (ap, const char *, real_name);
+ VA_FIXEDARG (ap, int, ident);
/* Generate the pseudo type name. */
pseudo_name = (char *)alloca (strlen (real_name) + 30);
/* Get the vtable decl. */
real_type = xref_tag (class_type_node, get_identifier (real_name), 1);
+ if (! TYPE_SIZE (real_type))
+ {
+ /* We never saw a definition of this type, so we need to tell the
+ compiler that this is an exported class, as indeed all of the
+ __*_type_info classes are. */
+ SET_CLASSTYPE_INTERFACE_KNOWN (real_type);
+ CLASSTYPE_INTERFACE_ONLY (real_type) = 1;
+ }
+
vtable_decl = get_vtable_decl (real_type, /*complete=*/1);
-
+ vtable_decl = build_unary_op (ADDR_EXPR, vtable_decl, 0);
+
+ /* We need to point into the middle of the vtable. */
+ vtable_decl = build (PLUS_EXPR,
+ TREE_TYPE (vtable_decl),
+ vtable_decl,
+ size_binop (MULT_EXPR,
+ size_int (2),
+ TYPE_SIZE_UNIT (vtable_entry_type)));
+ TREE_CONSTANT (vtable_decl) = 1;
+
/* First field is the pseudo type_info base class. */
- fields[0] = build_lang_decl (FIELD_DECL, NULL_TREE, ti_desc_type_node);
+ fields[0] = build_decl (FIELD_DECL, NULL_TREE, ti_desc_type_node);
/* Now add the derived fields. */
for (ix = 0; (field_decl = va_arg (ap, tree));)
pseudo_type = make_aggr_type (RECORD_TYPE);
finish_builtin_type (pseudo_type, pseudo_name, fields, ix, ptr_type_node);
TYPE_HAS_CONSTRUCTOR (pseudo_type) = 1;
- va_end (ap);
-
+
result = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE);
TINFO_VTABLE_DECL (result) = vtable_decl;
TINFO_PSEUDO_TYPE (result) = pseudo_type;
+ VA_CLOSE (ap);
return result;
}
return desc;
/* Add number of bases and trailing array of base_class_type_info. */
- array_domain = build_index_type (build_int_2 (num_bases, 0));
+ array_domain = build_index_type (size_int (num_bases));
base_array = build_array_type (base_desc_type_node, array_domain);
push_nested_namespace (abi_node);
desc = create_pseudo_type_info
("__vmi_class_type_info", num_bases,
- build_lang_decl (FIELD_DECL, NULL_TREE, integer_type_node),
- build_lang_decl (FIELD_DECL, NULL_TREE, integer_type_node),
- build_lang_decl (FIELD_DECL, NULL_TREE, base_array),
+ build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
+ build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
+ build_decl (FIELD_DECL, NULL_TREE, base_array),
NULL);
pop_nested_namespace (abi_node);
tree fields[2];
ti_desc_type_node = make_aggr_type (RECORD_TYPE);
- fields[0] = build_lang_decl (FIELD_DECL, NULL_TREE, const_ptr_type_node);
- fields[1] = build_lang_decl (FIELD_DECL, NULL_TREE, const_string_type_node);
+ fields[0] = build_decl (FIELD_DECL, NULL_TREE, const_ptr_type_node);
+ fields[1] = build_decl (FIELD_DECL, NULL_TREE, const_string_type_node);
finish_builtin_type (ti_desc_type_node, "__type_info_pseudo",
fields, 1, ptr_type_node);
TYPE_HAS_CONSTRUCTOR (ti_desc_type_node) = 1;
("__fundamental_type_info", 0,
NULL);
- /* Pointer type_info. Adds two fields, qualification mask
- and pointer to the pointed to type. */
- ptr_desc_type_node = create_pseudo_type_info
- ("__pointer_type_info", 0,
- build_lang_decl (FIELD_DECL, NULL_TREE, integer_type_node),
- build_lang_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
- NULL);
-
/* Array, function and enum type_info. No additional fields. */
ary_desc_type_node = create_pseudo_type_info
("__array_type_info", 0,
/* Class type_info. Add a flags field. */
class_desc_type_node = create_pseudo_type_info
("__class_type_info", 0,
- build_lang_decl (FIELD_DECL, NULL_TREE, integer_type_node),
NULL);
- /* Single public non-virtual base class. Add pointer to base class. */
+ /* Single public non-virtual base class. Add pointer to base class.
+ This is really a descendant of __class_type_info. */
si_class_desc_type_node = create_pseudo_type_info
("__si_class_type_info", 0,
- build_lang_decl (FIELD_DECL, NULL_TREE, integer_type_node),
- build_lang_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
+ build_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
NULL);
/* Base class internal helper. Pointer to base type, offset to base,
flags. */
{
- tree fields[3];
+ tree fields[2];
- fields[0] = build_lang_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
- fields[1] = build_lang_decl (FIELD_DECL, NULL_TREE, ptrdiff_type_node),
- fields[2] = build_lang_decl (FIELD_DECL, NULL_TREE, integer_type_node),
+ fields[0] = build_decl (FIELD_DECL, NULL_TREE, ptr_type_info);
+ fields[1] = build_decl (FIELD_DECL, NULL_TREE, integer_types[itk_long]);
base_desc_type_node = make_aggr_type (RECORD_TYPE);
finish_builtin_type (base_desc_type_node, "__base_class_type_info_pseudo",
- fields, 2, ptr_type_node);
+ fields, 1, ptr_type_node);
TYPE_HAS_CONSTRUCTOR (base_desc_type_node) = 1;
}
/* General heirarchy is created as necessary in this vector. */
vmi_class_desc_type_node = make_tree_vec (10);
- /* Pointer to member data type_info. Add pointer to the class, pointer
- to the member's type info and qualifications flags. */
- ptmd_desc_type_node = create_pseudo_type_info
+ /* Pointer type_info. Adds two fields, qualification mask
+ and pointer to the pointed to type. This is really a descendant of
+ __pbase_type_info. */
+ ptr_desc_type_node = create_pseudo_type_info
+ ("__pointer_type_info", 0,
+ build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
+ build_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
+ NULL);
+
+ /* Pointer to member data type_info. Add qualifications flags,
+ pointer to the member's type info and pointer to the class.
+ This is really a descendant of __pbase_type_info. */
+ ptm_desc_type_node = create_pseudo_type_info
("__pointer_to_member_type_info", 0,
- build_lang_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
- build_lang_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
- build_lang_decl (FIELD_DECL, NULL_TREE, integer_type_node),
+ build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
+ build_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
+ build_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
NULL);
pop_nested_namespace (abi_node);
/* Emit the type_info descriptors which are guaranteed to be in the runtime
support. Generating them here guarantees consistency with the other
structures. We use the following heuristic to determine when the runtime
- is being generated. If std::__fundamental_type_info is defined, and it's
+ is being generated. If std::__fundamental_type_info is defined, and its
destructor is defined, then the runtime is being built. */
void
&void_type_node,
&boolean_type_node,
&wchar_type_node,
- #if 0
- &signed_wchar_type_node, &unsigned_wchar_type_node,
- #endif
&char_type_node, &signed_char_type_node, &unsigned_char_type_node,
&short_integer_type_node, &short_unsigned_type_node,
&integer_type_node, &unsigned_type_node,
&long_integer_type_node, &long_unsigned_type_node,
&long_long_integer_type_node, &long_long_unsigned_type_node,
&float_type_node, &double_type_node, &long_double_type_node,
-
- /* GCC extension types */
- #if 0
- &complex_integer_type_node,
- &complex_float_type_node, &complex_double_type_node,
- &complex_long_double_type_node,
- #endif
-
0
};
int ix;
actual type this is describing. The DECL_ASSEMBLER_NAME of the generated
definition is set to that of the supplied decl, so that they can be tied
up. Mark the supplied decl as having been dealt with. Emitting one
- definitions might cause other declarations to be emitted.
+ definition might cause other definitions to be required.
We need to do things this way, because we're trying to do something like
tinfo_type = TREE_TYPE (DECL_NAME (tinfo_decl));
my_friendly_assert (tinfo_type != NULL_TREE, 20000120);
+ if (!DECL_NEEDED_P (tinfo_decl))
+ return 0;
/* Say we've dealt with it. */
TREE_TYPE (DECL_NAME (tinfo_decl)) = NULL_TREE;
- if (!DECL_NEEDED_P (tinfo_decl))
- return 0;
create_tinfo_types ();
decl = synthesize_tinfo_var (tinfo_type, DECL_ASSEMBLER_NAME (tinfo_decl));
projects / gcc.git / blobdiff