--- /dev/null
+/* RunTime Type Identification
+ Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+
+This file is part of GNU CC.
+
+GNU CC 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.
+
+GNU CC 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 GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
+
+
+#include "config.h"
+#include "tree.h"
+#include "cp-tree.h"
+#include "flags.h"
+#include "output.h"
+
+#undef NULL
+#define NULL 0
+
+extern tree define_function ();
+extern tree build_t_desc_overload ();
+extern struct obstack *permanent_obstack;
+
+/* in c-common.c */
+extern tree combine_strings PROTO((tree));
+\f
+/* Given the expression EXP of type `class *', return the head
+ of the object pointed to by EXP. */
+tree
+build_headof (exp)
+ tree exp;
+{
+ tree type = TREE_TYPE (exp);
+ tree vptr, offset;
+
+ if (TREE_CODE (type) != POINTER_TYPE)
+ {
+ error ("`headof' applied to non-pointer type");
+ return error_mark_node;
+ }
+ type = TREE_TYPE (type);
+
+ if (!TYPE_VIRTUAL_P (type) || CLASSTYPE_VFIELD (type) == NULL_TREE)
+ return exp;
+
+ vptr = fold (size_binop (PLUS_EXPR,
+ size_binop (FLOOR_DIV_EXPR,
+ DECL_FIELD_BITPOS (CLASSTYPE_VFIELD (type)),
+ size_int (BITS_PER_UNIT)),
+ exp));
+ vptr = build1 (INDIRECT_REF, build_pointer_type (vtable_entry_type), vptr);
+
+ if (flag_vtable_thunks)
+ offset = build_array_ref (vptr, integer_zero_node);
+ else
+ offset = build_component_ref (build_array_ref (vptr, integer_zero_node),
+ delta_identifier,
+ NULL_TREE, 0);
+
+ type = build_type_variant (ptr_type_node, TREE_READONLY (exp),
+ TREE_THIS_VOLATILE (exp));
+ return build (PLUS_EXPR, type, exp,
+ convert (ptrdiff_type_node, offset));
+}
+\f
+/* Return the type_info node associated with the expression EXP. If EXP is
+ a reference to a polymorphic class, return the dynamic type; otherwise
+ return the static type of the expression. */
+tree
+build_typeid (exp)
+ tree exp;
+{
+ tree type;
+
+ if (!flag_rtti)
+ cp_error ("cannot take typeid of object when -frtti is not specified");
+
+ if (exp == error_mark_node)
+ return error_mark_node;
+
+ type = TREE_TYPE (exp);
+
+ /* Strip top-level cv-qualifiers. */
+ type = TYPE_MAIN_VARIANT (type);
+
+ /* if b is an instance of B, typeid(b) == typeid(B). Do this before
+ reference trickiness. */
+ if (TREE_CODE (exp) == VAR_DECL && TREE_CODE (type) == RECORD_TYPE)
+ return get_typeid (type);
+
+ /* peel back references, so they match. */
+ if (TREE_CODE (type) == REFERENCE_TYPE)
+ type = TREE_TYPE (type);
+
+ /* Peel off cv qualifiers. */
+ type = TYPE_MAIN_VARIANT (type);
+
+ /* Apply trivial conversion T -> T& for dereferenced ptrs. */
+ if (TREE_CODE (type) == RECORD_TYPE)
+ type = build_reference_type (type);
+
+ /* If exp is a reference to polymorphic type, get the real type_info. */
+ if (TREE_CODE (type) == REFERENCE_TYPE && TYPE_VIRTUAL_P (TREE_TYPE (type)))
+ {
+ /* build reference to type_info from vtable. */
+ tree t;
+
+ if (flag_vtable_thunks)
+ t = build_vfn_ref ((tree *) NULL_TREE, exp, integer_one_node);
+ else
+ t = build_vfn_ref ((tree *) NULL_TREE, exp, integer_zero_node);
+
+ TREE_TYPE (t) = build_pointer_type (__class_desc_type_node);
+ t = build_indirect_ref (t, NULL);
+ return t;
+ }
+
+ /* otherwise return the type_info for the static type of the expr. */
+ return get_typeid (type);
+}
+
+/* Return the type_info object for TYPE, creating it if necessary. */
+tree
+get_typeid (type)
+ tree type;
+{
+ tree t, td;
+
+ if (type == error_mark_node)
+ return error_mark_node;
+
+ /* Is it useful (and/or correct) to have different typeids for `T &'
+ and `T'? */
+ if (TREE_CODE (type) == REFERENCE_TYPE)
+ type = TREE_TYPE (type);
+
+ td = build_t_desc (type, 1);
+ if (td == error_mark_node)
+ return error_mark_node;
+
+ t = TREE_OPERAND (td, 0);
+ return t;
+}
+
+/* Get a bad_cast node for the program to throw...
+
+ See libstdc++::exception{,.cc} for __bad_cast_object */
+tree
+get_bad_cast_node ()
+{
+ static tree t;
+ if (t == NULL_TREE
+ && (t = lookup_name (get_identifier ("__bad_cast_object"), 0))
+ == NULL_TREE)
+ {
+ error ("you must #include <typeinfo>");
+ return error_mark_node;
+ }
+ return t;
+}
+
+/* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
+ paper. */
+tree
+build_dynamic_cast (type, expr)
+ tree type, expr;
+{
+ enum tree_code tc = TREE_CODE (type);
+ tree exprtype = TREE_TYPE (expr);
+ enum tree_code ec = TREE_CODE (exprtype);
+ tree retval;
+
+ if (type == error_mark_node || expr == error_mark_node)
+ return error_mark_node;
+
+ switch (tc)
+ {
+ case POINTER_TYPE:
+ if (ec == REFERENCE_TYPE)
+ {
+ expr = convert_from_reference (expr);
+ exprtype = TREE_TYPE (expr);
+ ec = TREE_CODE (exprtype);
+ }
+ if (ec != POINTER_TYPE)
+ goto fail;
+ if (TREE_CODE (TREE_TYPE (exprtype)) != RECORD_TYPE)
+ goto fail;
+ if (TYPE_SIZE (TREE_TYPE (exprtype)) == 0)
+ goto fail;
+ if (TREE_READONLY (TREE_TYPE (exprtype)) &&
+ ! TYPE_READONLY (TREE_TYPE (type)))
+ goto fail;
+ if (TYPE_MAIN_VARIANT (TREE_TYPE (type)) == void_type_node)
+ break;
+ /* else fall through */
+ case REFERENCE_TYPE:
+ if (TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
+ && TYPE_SIZE (TREE_TYPE (type)) != NULL_TREE)
+ break;
+ /* else fall through */
+ default:
+ goto fail;
+ }
+
+ /* Apply trivial conversion T -> T& for dereferenced ptrs. */
+ if (ec == RECORD_TYPE)
+ {
+ exprtype = build_type_variant (exprtype, TREE_READONLY (expr),
+ TREE_THIS_VOLATILE (expr));
+ exprtype = build_reference_type (exprtype);
+ expr = convert_to_reference (exprtype, expr, CONV_IMPLICIT,
+ LOOKUP_NORMAL, NULL_TREE);
+ ec = REFERENCE_TYPE;
+ }
+
+ if (tc == REFERENCE_TYPE)
+ {
+ if (ec != REFERENCE_TYPE)
+ goto fail;
+ if (TREE_CODE (TREE_TYPE (exprtype)) != RECORD_TYPE)
+ goto fail;
+ if (TYPE_SIZE (TREE_TYPE (exprtype)) == 0)
+ goto fail;
+ if (TREE_READONLY (TREE_TYPE (exprtype)) &&
+ ! TYPE_READONLY (TREE_TYPE (type)))
+ goto fail;
+ }
+
+ /* If *type is an unambiguous accessible base class of *exprtype,
+ convert statically. */
+ {
+ int distance;
+ tree path;
+
+ distance = get_base_distance (TREE_TYPE (type), TREE_TYPE (exprtype), 1,
+ &path);
+ if (distance >= 0)
+ return build_vbase_path (PLUS_EXPR, type, expr, path, 0);
+ }
+
+ /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
+ if (TYPE_VIRTUAL_P (TREE_TYPE (exprtype)))
+ {
+ /* if TYPE is `void *', return pointer to complete object. */
+ if (tc == POINTER_TYPE
+ && TYPE_MAIN_VARIANT (TREE_TYPE (type)) == void_type_node)
+ {
+ /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
+ if (TREE_CODE (expr) == ADDR_EXPR
+ && TREE_CODE (TREE_OPERAND (expr, 0)) == VAR_DECL
+ && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == RECORD_TYPE)
+ return build1 (NOP_EXPR, type, expr);
+
+ return build_headof (expr);
+ }
+ else
+ {
+ tree retval;
+ tree result, td1, td2, elems, tmp1, expr1;
+
+ /* If we got here, we can't convert statically. Therefore,
+ dynamic_cast<D&>(b) (b an object) cannot succeed. */
+ if (ec == REFERENCE_TYPE)
+ {
+ if (TREE_CODE (expr) == VAR_DECL
+ && TREE_CODE (TREE_TYPE (expr)) == RECORD_TYPE)
+ {
+ cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
+ expr, type);
+ return build_throw (get_bad_cast_node ());
+ }
+ }
+ /* Ditto for dynamic_cast<D*>(&b). */
+ else if (TREE_CODE (expr) == ADDR_EXPR)
+ {
+ tree op = TREE_OPERAND (expr, 0);
+ if (TREE_CODE (op) == VAR_DECL
+ && TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE)
+ {
+ cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
+ expr, type);
+ retval = build_int_2 (0, 0);
+ TREE_TYPE (retval) = type;
+ return retval;
+ }
+ }
+
+ expr1 = expr;
+ if (tc == REFERENCE_TYPE)
+ expr1 = build_unary_op (ADDR_EXPR, expr1, 0);
+
+ /* Build run-time conversion. */
+ expr1 = build_headof (expr1);
+
+ if (ec == POINTER_TYPE)
+ td1 = build_typeid (build_indirect_ref (expr, NULL_PTR));
+ else
+ td1 = build_typeid (expr);
+
+ if (tc == POINTER_TYPE)
+ td2 = get_typeid (TREE_TYPE (type));
+ else
+ td2 = get_typeid (TYPE_MAIN_VARIANT (TREE_TYPE (type)));
+
+ elems = tree_cons (NULL_TREE, td2,
+ tree_cons (NULL_TREE, build_int_2 (1, 0),
+ tree_cons (NULL_TREE, expr1, NULL_TREE)));
+ result = build_method_call (td1,
+ get_identifier ("__rtti_match"), elems, NULL_TREE, LOOKUP_NORMAL);
+
+ if (tc == REFERENCE_TYPE)
+ {
+ expr1 = build_throw (get_bad_cast_node ());
+ expr1 = build_compound_expr (tree_cons (NULL_TREE, expr1,
+ build_tree_list (NULL_TREE, convert (type, integer_zero_node))));
+ TREE_TYPE (expr1) = type;
+ result = save_expr (result);
+ return build (COND_EXPR, type, result, result, expr1);
+ }
+
+ /* Now back to the type we want from a void*. */
+ result = convert (type, result);
+ return result;
+ }
+ }
+
+ fail:
+ cp_error ("cannot dynamic_cast `%E' (of type `%#T') to type `%#T'",
+ expr, exprtype, type);
+ return error_mark_node;
+}
+\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. */
+
+static tree
+build_generic_desc (tdecl, type, elems)
+ tree tdecl;
+ tree type;
+ tree elems;
+{
+ tree init = elems;
+ int toplev = global_bindings_p ();
+
+ TREE_CONSTANT (init) = 1;
+ TREE_STATIC (init) = 1;
+ TREE_READONLY (init) = 1;
+
+ TREE_TYPE (tdecl) = type;
+ DECL_INITIAL (tdecl) = init;
+ TREE_STATIC (tdecl) = 1;
+ DECL_SIZE (tdecl) = NULL_TREE;
+ layout_decl (tdecl, 0);
+ if (! toplev)
+ push_to_top_level ();
+ cp_finish_decl (tdecl, init, NULL_TREE, 0, 0);
+ if (! toplev)
+ pop_from_top_level ();
+
+ if (! TREE_USED (tdecl))
+ {
+ assemble_external (tdecl);
+ TREE_USED (tdecl) = 1;
+ }
+
+ return IDENTIFIER_AS_DESC (DECL_NAME (tdecl));
+}
+
+/* Build an initializer for a __bltn_desc node. */
+static tree
+build_bltn_desc (tdecl, type)
+ tree tdecl;
+ tree type;
+{
+ tree elems, t;
+
+ if (type == boolean_type_node)
+ t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_BOOL"),
+ 0, 0);
+ else if (type == char_type_node)
+ t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_CHAR"),
+ 0, 0);
+ else if (type == short_integer_type_node)
+ t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_SHORT"),
+ 0, 0);
+ else if (type == integer_type_node)
+ t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_INT"),
+ 0, 0);
+ else if (type == long_integer_type_node)
+ t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_LONG"),
+ 0, 0);
+ else if (type == long_long_integer_type_node)
+ t = lookup_field (__bltn_desc_type_node,
+ get_identifier("_RTTI_BI_LONGLONG"), 0, 0);
+ else if (type == float_type_node)
+ t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_FLOAT"),
+ 0, 0);
+ else if (type == double_type_node)
+ t = lookup_field (__bltn_desc_type_node,
+ get_identifier("_RTTI_BI_DOUBLE"), 0, 0);
+ else if (type == long_double_type_node)
+ t = lookup_field (__bltn_desc_type_node,
+ get_identifier("_RTTI_BI_LDOUBLE"), 0, 0);
+ else if (type == unsigned_char_type_node)
+ t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_UCHAR"),
+ 0, 0);
+ else if (type == short_unsigned_type_node)
+ t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_USHORT"),
+ 0, 0);
+ else if (type == unsigned_type_node)
+ t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_UINT"),
+ 0, 0);
+ else if (type == long_unsigned_type_node)
+ t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_ULONG"),
+ 0, 0);
+ else if (type == long_long_unsigned_type_node)
+ t = lookup_field (__bltn_desc_type_node,
+ get_identifier("_RTTI_BI_ULONGLONG"), 0, 0);
+ else if (type == signed_char_type_node)
+ t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_SCHAR"),
+ 0, 0);
+ else if (type == wchar_type_node)
+ t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_WCHAR"),
+ 0, 0);
+ else if (type == void_type_node)
+ t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_VOID"),
+ 0, 0);
+ else
+ {
+ cp_compiler_error ("type `%T' not handled as a built-in type");
+ }
+
+ elems = tree_cons (NULL_TREE, t, NULL_TREE);
+ return build_generic_desc (tdecl, __bltn_desc_type_node, elems);
+}
+
+/* Build an initializer for a __user_desc node. */
+static tree
+build_user_desc (tdecl)
+ tree tdecl;
+{
+ tree elems, name_string, t;
+ tree tname = DECL_NAME (tdecl);
+
+ name_string = combine_strings (build_string
+ (IDENTIFIER_LENGTH (tname)+1, IDENTIFIER_POINTER (tname)));
+ elems = name_string;
+ return build_generic_desc (tdecl, __user_desc_type_node, elems);
+}
+
+/* Build an initializer for a __class_type_info node. */
+static tree
+build_class_desc (tdecl, type)
+ tree tdecl;
+ tree type;
+{
+ tree tname = DECL_NAME (tdecl);
+ tree name_string;
+
+ int i = CLASSTYPE_N_BASECLASSES (type);
+ int n_base = i;
+ int base_cnt = 0;
+ tree binfos = TYPE_BINFO_BASETYPES (type);
+ tree vb = CLASSTYPE_VBASECLASSES (type);
+ tree base, elems, access, offset, isvir;
+ tree base_list, off_list, acc_list, isvir_list;
+ tree t;
+ static tree acc_pub = NULL_TREE;
+ static tree acc_pro = NULL_TREE;
+ static tree acc_pri = NULL_TREE;
+
+ if (acc_pub == NULL_TREE)
+ {
+ acc_pub = lookup_field (__class_desc_type_node,
+ get_identifier("_RTTI_ACCESS_PUBLIC"), 0, 0);
+ acc_pro = lookup_field (__class_desc_type_node,
+ get_identifier("_RTTI_ACCESS_PROTECTED"), 0, 0);
+ acc_pri = lookup_field (__class_desc_type_node,
+ get_identifier("_RTTI_ACCESS_PRIVATE"), 0, 0);
+ }
+
+ base_list = build_tree_list (NULL_TREE, integer_zero_node);
+ off_list = build_tree_list (NULL_TREE, integer_zero_node);
+ acc_list = build_tree_list (NULL_TREE, integer_zero_node);
+ isvir_list = build_tree_list (NULL_TREE, integer_zero_node);
+ while (--i >= 0)
+ {
+ tree binfo = TREE_VEC_ELT (binfos, i);
+
+ base = build_t_desc (BINFO_TYPE (binfo), 1);
+ if (TREE_VIA_VIRTUAL (binfo))
+ {
+ tree t = BINFO_TYPE (binfo);
+ char *name;
+ tree field;
+ int off;
+
+ name = (char *) alloca (TYPE_NAME_LENGTH (t)+sizeof (VBASE_NAME)+1);
+ sprintf (name, VBASE_NAME_FORMAT, TYPE_NAME_STRING (t));
+ field = lookup_field (type, get_identifier (name), 0, 0);
+ offset = size_binop (FLOOR_DIV_EXPR,
+ DECL_FIELD_BITPOS (field), size_int (BITS_PER_UNIT));
+ }
+ else
+ offset = BINFO_OFFSET (binfo);
+
+ if (TREE_VIA_PUBLIC (binfo))
+ access = acc_pub;
+ else if (TREE_VIA_PROTECTED (binfo))
+ access = acc_pro;
+ else
+ access = acc_pri;
+ if (TREE_VIA_VIRTUAL (binfo))
+ isvir = build_int_2 (1, 0);
+ else
+ isvir = build_int_2 (0, 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++;
+ }
+#if 0
+ i = n_base;
+ while (vb)
+ {
+ tree b;
+ access = acc_pub;
+ 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 = acc_pub;
+ else if (TREE_VIA_PROTECTED (b))
+ access = acc_pro;
+ else
+ access = acc_pri;
+ 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
+ base_list = finish_table (NULL_TREE, build_pointer_type (__t_desc_type_node),
+ base_list, 0);
+ off_list = finish_table (NULL_TREE, integer_type_node,
+ off_list, 0);
+ isvir_list = finish_table (NULL_TREE, integer_type_node,
+ isvir_list, 0);
+ acc_list = finish_table (NULL_TREE, __access_mode_type_node,
+ acc_list, 0);
+
+
+ name_string = combine_strings (build_string (IDENTIFIER_LENGTH (tname)+1, IDENTIFIER_POINTER (tname)));
+
+ elems = tree_cons (NULL_TREE, name_string,
+ tree_cons (NULL_TREE, default_conversion (base_list),
+ tree_cons (NULL_TREE, default_conversion (off_list),
+ tree_cons (NULL_TREE, default_conversion (isvir_list),
+ tree_cons (NULL_TREE, default_conversion (acc_list),
+ tree_cons (NULL_TREE, build_int_2 (base_cnt, 0), NULL_TREE))))));
+
+ return build_generic_desc (tdecl, __class_desc_type_node, elems);
+}
+
+/* Build an initializer for a __pointer_type_info node. */
+static tree
+build_ptr_desc (tdecl, type)
+ tree tdecl;
+ tree type;
+{
+ tree t, elems;
+
+ t = TREE_TYPE (type);
+ t = build_t_desc (t, 1);
+ t = build_indirect_ref (t, NULL);
+ elems = tree_cons (NULL_TREE, t, NULL_TREE);
+ return build_generic_desc (tdecl, __ptr_desc_type_node, elems);
+}
+
+/* Build an initializer for a __attr_type_info node. */
+static tree
+build_attr_desc (tdecl, type)
+ tree tdecl;
+ tree type;
+{
+ tree elems, t, attrval;
+
+ if (TYPE_READONLY (type))
+ {
+ if (TYPE_VOLATILE (type))
+ attrval = lookup_field (__attr_desc_type_node,
+ get_identifier("_RTTI_ATTR_CONSTVOL"), 0, 0);
+ else
+ attrval = lookup_field (__attr_desc_type_node,
+ get_identifier("_RTTI_ATTR_CONST"), 0, 0);
+ }
+ else
+ {
+ if (TYPE_VOLATILE (type))
+ attrval = lookup_field (__attr_desc_type_node,
+ get_identifier("_RTTI_ATTR_VOLATILE"), 0, 0);
+ }
+ t = build_t_desc (TYPE_MAIN_VARIANT (type), 1);
+ t = build_indirect_ref (t , NULL);
+ elems = tree_cons (NULL_TREE, attrval, tree_cons (NULL_TREE, t, NULL_TREE));
+ return build_generic_desc (tdecl, __attr_desc_type_node, elems);
+}
+
+/* Build an initializer for a __func_type_info node. */
+static tree
+build_func_desc (tdecl)
+ tree tdecl;
+{
+ tree elems, name_string;
+ tree tname = DECL_NAME (tdecl);
+
+ name_string = combine_strings (build_string
+ (IDENTIFIER_LENGTH (tname)+1, IDENTIFIER_POINTER (tname)));
+ elems = name_string;
+ return build_generic_desc (tdecl, __func_desc_type_node, elems);
+}
+
+/* Build an initializer for a __ptmf_type_info node. */
+static tree
+build_ptmf_desc (tdecl, type)
+ tree tdecl;
+ tree type;
+{
+ tree elems, name_string;
+ tree tname = DECL_NAME (tdecl);
+
+ name_string = combine_strings (build_string
+ (IDENTIFIER_LENGTH (tname)+1, IDENTIFIER_POINTER (tname)));
+ elems = name_string;
+ return build_generic_desc (tdecl, __ptmf_desc_type_node, elems);
+}
+
+/* Build an initializer for a __ptmd_type_info node. */
+static tree
+build_ptmd_desc (tdecl, type)
+ tree tdecl;
+ tree type;
+{
+ tree tc, t, elems;
+ tc = build_t_desc (TYPE_OFFSET_BASETYPE (type), 1);
+ tc = build_indirect_ref (tc , NULL);
+ t = build_t_desc (TREE_TYPE (type), 1);
+ t = build_indirect_ref (t , NULL);
+ elems = tree_cons (NULL_TREE, tc,
+ tree_cons (NULL_TREE, t, NULL_TREE));
+ return build_generic_desc (tdecl, __ptmd_desc_type_node, elems);
+}
+
+struct uninst_st {
+ tree type;
+ struct uninst_st *next;
+};
+typedef struct uninst_st uninst_node;
+static uninst_node * uninst_desc = (uninst_node *)NULL;
+
+static void
+add_uninstantiated_desc (type)
+ tree type;
+{
+ uninst_node *t;
+
+ t = (uninst_node *) xmalloc (sizeof (struct uninst_st));
+ t->type = type;
+ t->next = uninst_desc;
+ uninst_desc = t;
+}
+
+/* We may choose to link the emitting of certain high use TDs for certain
+ objects, we do that here. Return the type to link against if such a
+ link exists, otherwise just return TYPE. */
+
+tree
+get_def_to_follow (type)
+ tree type;
+{
+#if 0
+ /* For now we don't lay out T&, T* TDs with the main TD for the object. */
+ /* Let T* and T& be written only when T is written (if T is an aggr).
+ We do this for const, but not for volatile, since volatile
+ is rare and const is not. */
+ if (!TYPE_VOLATILE (taggr)
+ && (TREE_CODE (taggr) == POINTER_TYPE
+ || TREE_CODE (taggr) == REFERENCE_TYPE)
+ && IS_AGGR_TYPE (TREE_TYPE (taggr)))
+ taggr = TREE_TYPE (taggr);
+#endif
+ return type;
+}
+
+/* build a general type_info node. */
+tree
+build_t_desc (type, definition)
+ tree type;
+ int definition;
+{
+ tree tdecl;
+ tree tname, name_string;
+ tree elems;
+ tree t, tt, taggr;
+
+ if (__ptmd_desc_type_node == NULL_TREE)
+ {
+ init_type_desc();
+ if (__ptmd_desc_type_node)
+ {
+ for ( ; uninst_desc; uninst_desc = uninst_desc->next )
+ build_t_desc (uninst_desc->type, 1);
+ }
+ }
+ if (__t_desc_type_node == NULL_TREE)
+ {
+ static int warned = 0;
+ if (! warned)
+ {
+ cp_error ("failed to build type descriptor node of '%T', maybe <typeinfo> not included", type);
+ }
+ warned = 1;
+ return error_mark_node;
+ }
+ if (__ptmd_desc_type_node == NULL_TREE)
+ {
+ add_uninstantiated_desc (type);
+ definition = 0;
+ }
+
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ tname = build_t_desc_overload (type);
+
+ if (!IDENTIFIER_AS_DESC (tname))
+ {
+ tdecl = build_decl (VAR_DECL, tname, __t_desc_type_node);
+ DECL_EXTERNAL (tdecl) = 1;
+ TREE_PUBLIC (tdecl) = 1;
+ tdecl = pushdecl_top_level (tdecl);
+ SET_IDENTIFIER_AS_DESC (tname, build_unary_op (ADDR_EXPR, tdecl, 0));
+ if (!definition)
+ cp_finish_decl (tdecl, NULL_TREE, NULL_TREE, 0, 0);
+ }
+ else
+ tdecl = TREE_OPERAND (IDENTIFIER_AS_DESC (tname), 0);
+
+ /* If it's not a definition, don't do anything more. */
+ if (!definition)
+ return IDENTIFIER_AS_DESC (tname);
+
+ /* If it has already been written, don't to anything more. */
+ /* Should this be on tdecl? */
+ if (TREE_ASM_WRITTEN (IDENTIFIER_AS_DESC (tname)))
+ return IDENTIFIER_AS_DESC (tname);
+
+ /* If we previously defined it, return the defined result. */
+ if (DECL_INITIAL (tdecl))
+ return IDENTIFIER_AS_DESC (tname);
+
+ taggr = get_def_to_follow (type);
+
+ /* If we know that we don't need to write out this type's
+ vtable, then don't write out it's type_info. Somebody
+ else will take care of that. */
+ if (IS_AGGR_TYPE (taggr) && CLASSTYPE_VFIELD (taggr))
+ {
+ /* Let's play follow the vtable. */
+ TREE_PUBLIC (tdecl) = CLASSTYPE_INTERFACE_KNOWN (taggr);
+ DECL_EXTERNAL (tdecl) = CLASSTYPE_INTERFACE_ONLY (taggr);
+ }
+ else
+ {
+ DECL_EXTERNAL (tdecl) = 0;
+ TREE_PUBLIC (tdecl) = (definition > 1);
+ }
+
+ if (DECL_EXTERNAL (tdecl))
+ return IDENTIFIER_AS_DESC (tname);
+
+ /* Show that we are defining the t_desc for this type. */
+ DECL_INITIAL (tdecl) = error_mark_node;
+ t = DECL_CONTEXT (tdecl);
+ if ( t && TREE_CODE_CLASS (TREE_CODE (t)) == 't')
+ pushclass (t, 2);
+
+ if (TYPE_VOLATILE (type) || TYPE_READONLY (type))
+ t = build_attr_desc (tdecl, type);
+ else if (TREE_CODE (type) == ARRAY_TYPE)
+ t = build_ptr_desc (tdecl, type);
+ else if (TREE_CODE (type) == POINTER_TYPE)
+ {
+ if (TREE_CODE (TREE_TYPE (type)) == OFFSET_TYPE)
+ {
+ type = TREE_TYPE (type);
+ t = build_ptmd_desc (tdecl, type);
+ }
+ else
+ {
+ t = build_ptr_desc (tdecl, type);
+ }
+ }
+ else if (TYPE_BUILT_IN (type))
+ t = build_bltn_desc (tdecl, type);
+ else if (IS_AGGR_TYPE (type))
+ {
+ if (TYPE_PTRMEMFUNC_P (type))
+ {
+ t = build_ptmf_desc (tdecl, type);
+ }
+ else
+ {
+ t = build_class_desc (tdecl, type);
+ }
+ }
+ else if (TREE_CODE (type) == FUNCTION_TYPE)
+ t = build_func_desc (tdecl);
+ else
+ t = build_user_desc (tdecl);
+
+ pop_obstacks ();
+ return t;
+}
+
+#if 0
+/* This is the old dossier type descriptor generation code, it's much
+ more extended than rtti. It's reserved for later use. */
+/* Build an initializer for a __t_desc node. So that we can take advantage
+ of recursion, we accept NULL for TYPE.
+ DEFINITION is greater than zero iff we must define the type descriptor
+ (as opposed to merely referencing it). 1 means treat according to
+ #pragma interface/#pragma implementation rules. 2 means define as
+ global and public, no matter what. */
+tree
+build_t_desc (type, definition)
+ tree type;
+ int definition;
+{
+ tree tdecl;
+ tree tname, name_string;
+ tree elems, fields;
+ tree parents, vbases, offsets, ivars, methods, target_type;
+ int method_count = 0, field_count = 0;
+
+ if (type == NULL_TREE)
+ return NULL_TREE;
+
+ tname = build_t_desc_overload (type);
+ if (IDENTIFIER_AS_DESC (tname)
+ && (!definition || TREE_ASM_WRITTEN (IDENTIFIER_AS_DESC (tname))))
+ return IDENTIFIER_AS_DESC (tname);
+
+ tdecl = lookup_name (tname, 0);
+ if (tdecl == NULL_TREE)
+ {
+ tdecl = build_decl (VAR_DECL, tname, __t_desc_type_node);
+ DECL_EXTERNAL (tdecl) = 1;
+ TREE_PUBLIC (tdecl) = 1;
+ tdecl = pushdecl_top_level (tdecl);
+ }
+ /* If we previously defined it, return the defined result. */
+ else if (definition && DECL_INITIAL (tdecl))
+ return IDENTIFIER_AS_DESC (tname);
+
+ if (definition)
+ {
+ tree taggr = type;
+ /* Let T* and T& be written only when T is written (if T is an aggr).
+ We do this for const, but not for volatile, since volatile
+ is rare and const is not. */
+ if (!TYPE_VOLATILE (taggr)
+ && (TREE_CODE (taggr) == POINTER_TYPE
+ || TREE_CODE (taggr) == REFERENCE_TYPE)
+ && IS_AGGR_TYPE (TREE_TYPE (taggr)))
+ taggr = TREE_TYPE (taggr);
+
+ /* If we know that we don't need to write out this type's
+ vtable, then don't write out it's dossier. Somebody
+ else will take care of that. */
+ if (IS_AGGR_TYPE (taggr) && CLASSTYPE_VFIELD (taggr))
+ {
+ if (CLASSTYPE_VTABLE_NEEDS_WRITING (taggr))
+ {
+ TREE_PUBLIC (tdecl) = ! CLASSTYPE_INTERFACE_ONLY (taggr)
+ && CLASSTYPE_INTERFACE_KNOWN (taggr);
+ DECL_EXTERNAL (tdecl) = 0;
+ }
+ else
+ {
+ if (write_virtuals != 0)
+ TREE_PUBLIC (tdecl) = 1;
+ }
+ }
+ else
+ {
+ DECL_EXTERNAL (tdecl) = 0;
+ TREE_PUBLIC (tdecl) = (definition > 1);
+ }
+ }
+ SET_IDENTIFIER_AS_DESC (tname, build_unary_op (ADDR_EXPR, tdecl, 0));
+
+ if (!definition || DECL_EXTERNAL (tdecl))
+ {
+ /* That's it! */
+ cp_finish_decl (tdecl, NULL_TREE, NULL_TREE, 0, 0);
+ return IDENTIFIER_AS_DESC (tname);
+ }
+
+ /* Show that we are defining the t_desc for this type. */
+ DECL_INITIAL (tdecl) = error_mark_node;
+
+ parents = build_tree_list (NULL_TREE, integer_zero_node);
+ vbases = build_tree_list (NULL_TREE, integer_zero_node);
+ offsets = build_tree_list (NULL_TREE, integer_zero_node);
+ methods = NULL_TREE;
+ ivars = NULL_TREE;
+
+ if (TYPE_LANG_SPECIFIC (type))
+ {
+ int i = CLASSTYPE_N_BASECLASSES (type);
+ tree method_vec = CLASSTYPE_METHOD_VEC (type);
+ tree *meth, *end;
+ tree binfos = TYPE_BINFO_BASETYPES (type);
+ tree vb = CLASSTYPE_VBASECLASSES (type);
+
+ while (--i >= 0)
+ parents = tree_cons (NULL_TREE, build_t_desc (BINFO_TYPE (TREE_VEC_ELT (binfos, i)), 0), parents);
+
+ while (vb)
+ {
+ vbases = tree_cons (NULL_TREE, build_t_desc (BINFO_TYPE (vb), 0), vbases);
+ offsets = tree_cons (NULL_TREE, BINFO_OFFSET (vb), offsets);
+ vb = TREE_CHAIN (vb);
+ }
+
+ if (method_vec)
+ for (meth = TREE_VEC_END (method_vec),
+ end = &TREE_VEC_ELT (method_vec, 0); meth-- != end; )
+ if (*meth)
+ {
+ methods = tree_cons (NULL_TREE, build_m_desc (*meth), methods);
+ method_count++;
+ }
+ }
+
+ if (IS_AGGR_TYPE (type))
+ {
+ for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
+ if (TREE_CODE (fields) == FIELD_DECL
+ || TREE_CODE (fields) == VAR_DECL)
+ {
+ ivars = tree_cons (NULL_TREE, build_i_desc (fields), ivars);
+ field_count++;
+ }
+ ivars = nreverse (ivars);
+ }
+
+ parents = finish_table (NULL_TREE, build_pointer_type (__t_desc_type_node), parents, 0);
+ vbases = finish_table (NULL_TREE, build_pointer_type (__t_desc_type_node), vbases, 0);
+ offsets = finish_table (NULL_TREE, integer_type_node, offsets, 0);
+ if (methods == NULL_TREE)
+ methods = null_pointer_node;
+ else
+ methods = build_unary_op (ADDR_EXPR,
+ finish_table (NULL_TREE, __m_desc_type_node, methods, 0),
+ 0);
+ if (ivars == NULL_TREE)
+ ivars = null_pointer_node;
+ else
+ ivars = build_unary_op (ADDR_EXPR,
+ finish_table (NULL_TREE, __i_desc_type_node, ivars, 0),
+ 0);
+ if (TREE_TYPE (type))
+ target_type = build_t_desc (TREE_TYPE (type), definition);
+ else
+ target_type = integer_zero_node;
+
+ name_string = combine_strings (build_string (IDENTIFIER_LENGTH (tname)+1, IDENTIFIER_POINTER (tname)));
+
+ elems = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, name_string, 0),
+ tree_cons (NULL_TREE,
+ TYPE_SIZE(type)? size_in_bytes(type) : integer_zero_node,
+ /* really should use bitfield initialization here. */
+ tree_cons (NULL_TREE, integer_zero_node,
+ tree_cons (NULL_TREE, target_type,
+ tree_cons (NULL_TREE, build_int_2 (field_count, 2),
+ tree_cons (NULL_TREE, build_int_2 (method_count, 2),
+ tree_cons (NULL_TREE, ivars,
+ tree_cons (NULL_TREE, methods,
+ tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, parents, 0),
+ tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, vbases, 0),
+ build_tree_list (NULL_TREE, build_unary_op (ADDR_EXPR, offsets, 0))))))))))));
+ return build_generic_desc (tdecl, elems);
+}
+
+/* Build an initializer for a __i_desc node. */
+tree
+build_i_desc (decl)
+ tree decl;
+{
+ tree elems, name_string;
+ tree taggr;
+
+ name_string = DECL_NAME (decl);
+ name_string = combine_strings (build_string (IDENTIFIER_LENGTH (name_string)+1, IDENTIFIER_POINTER (name_string)));
+
+ /* Now decide whether this ivar should cause it's type to get
+ def'd or ref'd in this file. If the type we are looking at
+ has a proxy definition, we look at the proxy (i.e., a
+ `foo *' is equivalent to a `foo'). */
+ taggr = TREE_TYPE (decl);
+
+ if ((TREE_CODE (taggr) == POINTER_TYPE
+ || TREE_CODE (taggr) == REFERENCE_TYPE)
+ && TYPE_VOLATILE (taggr) == 0)
+ taggr = TREE_TYPE (taggr);
+
+ elems = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, name_string, 0),
+ tree_cons (NULL_TREE, DECL_FIELD_BITPOS (decl),
+ build_tree_list (NULL_TREE, build_t_desc (TREE_TYPE (decl),
+ ! IS_AGGR_TYPE (taggr)))));
+ taggr = build (CONSTRUCTOR, __i_desc_type_node, NULL_TREE, elems);
+ TREE_CONSTANT (taggr) = 1;
+ TREE_STATIC (taggr) = 1;
+ TREE_READONLY (taggr) = 1;
+ return taggr;
+}
+
+/* Build an initializer for a __m_desc node. */
+tree
+build_m_desc (decl)
+ tree decl;
+{
+ tree taggr, elems, name_string;
+ tree parm_count, req_count, vindex, vcontext;
+ tree parms;
+ int p_count, r_count;
+ tree parm_types = NULL_TREE;
+
+ for (parms = TYPE_ARG_TYPES (TREE_TYPE (decl)), p_count = 0, r_count = 0;
+ parms != NULL_TREE; parms = TREE_CHAIN (parms), p_count++)
+ {
+ taggr = TREE_VALUE (parms);
+ if ((TREE_CODE (taggr) == POINTER_TYPE
+ || TREE_CODE (taggr) == REFERENCE_TYPE)
+ && TYPE_VOLATILE (taggr) == 0)
+ taggr = TREE_TYPE (taggr);
+
+ parm_types = tree_cons (NULL_TREE, build_t_desc (TREE_VALUE (parms),
+ ! IS_AGGR_TYPE (taggr)),
+ parm_types);
+ if (TREE_PURPOSE (parms) == NULL_TREE)
+ r_count++;
+ }
+
+ parm_types = finish_table (NULL_TREE, build_pointer_type (__t_desc_type_node),
+ nreverse (parm_types), 0);
+ parm_count = build_int_2 (p_count, 0);
+ req_count = build_int_2 (r_count, 0);
+
+ if (DECL_VINDEX (decl))
+ vindex = DECL_VINDEX (decl);
+ else
+ vindex = integer_zero_node;
+ if (DECL_CONTEXT (decl)
+ && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (decl))) == 't')
+ vcontext = build_t_desc (DECL_CONTEXT (decl), 0);
+ else
+ vcontext = integer_zero_node;
+ name_string = DECL_NAME (decl);
+ if (name_string == NULL)
+ name_string = DECL_ASSEMBLER_NAME (decl);
+ name_string = combine_strings (build_string (IDENTIFIER_LENGTH (name_string)+1, IDENTIFIER_POINTER (name_string)));
+
+ /* Now decide whether the return type of this mvar
+ should cause it's type to get def'd or ref'd in this file.
+ If the type we are looking at has a proxy definition,
+ we look at the proxy (i.e., a `foo *' is equivalent to a `foo'). */
+ taggr = TREE_TYPE (TREE_TYPE (decl));
+
+ if ((TREE_CODE (taggr) == POINTER_TYPE
+ || TREE_CODE (taggr) == REFERENCE_TYPE)
+ && TYPE_VOLATILE (taggr) == 0)
+ taggr = TREE_TYPE (taggr);
+
+ elems = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, name_string, 0),
+ tree_cons (NULL_TREE, vindex,
+ tree_cons (NULL_TREE, vcontext,
+ tree_cons (NULL_TREE, build_t_desc (TREE_TYPE (TREE_TYPE (decl)),
+ ! IS_AGGR_TYPE (taggr)),
+ tree_cons (NULL_TREE, build_c_cast (build_pointer_type (default_function_type), build_unary_op (ADDR_EXPR, decl, 0), 0),
+ tree_cons (NULL_TREE, parm_count,
+ tree_cons (NULL_TREE, req_count,
+ build_tree_list (NULL_TREE, build_unary_op (ADDR_EXPR, parm_types, 0)))))))));
+
+ taggr = build (CONSTRUCTOR, __m_desc_type_node, NULL_TREE, elems);
+ TREE_CONSTANT (taggr) = 1;
+ TREE_STATIC (taggr) = 1;
+ TREE_READONLY (taggr) = 1;
+ return taggr;
+}
+#endif /* dossier */
OSDN Git Service
