#include "config.h"
#include "system.h"
#include "tree.h"
#include "cp-tree.h"
#include "flags.h"
#include "output.h"
#include "assert.h"
#include "toplev.h"
#ifndef INT_TYPE_SIZE
#define INT_TYPE_SIZE BITS_PER_WORD
#endif
extern struct obstack permanent_obstack;
static tree call_void_fn PROTO((const char *));
static tree build_headof_sub PROTO((tree));
static tree build_headof PROTO((tree));
static tree get_tinfo_var PROTO((tree));
static tree ifnonnull PROTO((tree, tree));
static tree build_dynamic_cast_1 PROTO((tree, tree));
static void expand_si_desc PROTO((tree, tree));
static void expand_class_desc PROTO((tree, tree));
static void expand_attr_desc PROTO((tree, tree));
static void expand_ptr_desc PROTO((tree, tree));
static void expand_generic_desc PROTO((tree, tree, const char *));
static tree throw_bad_cast PROTO((void));
static tree throw_bad_typeid PROTO((void));
tree type_info_type_node;
tree tinfo_fn_id;
tree tinfo_fn_type;
void
init_rtti_processing ()
{
if (flag_honor_std)
push_namespace (get_identifier ("std"));
type_info_type_node = xref_tag
(class_type_node, get_identifier ("type_info"), 1);
if (flag_honor_std)
pop_namespace ();
tinfo_fn_id = get_identifier ("__tf");
tinfo_fn_type = build_function_type
(build_reference_type (build_qualified_type (type_info_type_node,
TYPE_QUAL_CONST)),
void_list_node);
}
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;
}
static tree
build_headof (exp)
tree exp;
{
tree type = TREE_TYPE (exp);
tree aref;
tree 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))
return exp;
if (CLASSTYPE_COM_INTERFACE (type))
{
cp_error ("RTTI not supported for COM interface type `%T'", type);
return error_mark_node;
}
if (!CLASSTYPE_VFIELDS (TREE_TYPE (TREE_TYPE (exp))))
exp = build_headof_sub (exp);
exp = save_expr (exp);
aref = build_vtbl_ref (build_indirect_ref (exp, NULL_PTR), integer_zero_node);
if (flag_vtable_thunks)
offset = aref;
else
offset = build_component_ref (aref, delta_identifier, NULL_TREE, 0);
type = build_qualified_type (ptr_type_node,
CP_TYPE_QUALS (TREE_TYPE (exp)));
return build (PLUS_EXPR, type, exp,
cp_convert (ptrdiff_type_node, offset));
}
static tree
call_void_fn (name)
const char *name;
{
tree d = get_identifier (name);
tree type;
if (IDENTIFIER_GLOBAL_VALUE (d))
d = IDENTIFIER_GLOBAL_VALUE (d);
else
{
push_obstacks (&permanent_obstack, &permanent_obstack);
type = build_function_type (void_type_node, void_list_node);
d = build_lang_decl (FUNCTION_DECL, d, type);
DECL_EXTERNAL (d) = 1;
TREE_PUBLIC (d) = 1;
DECL_ARTIFICIAL (d) = 1;
pushdecl_top_level (d);
make_function_rtl (d);
pop_obstacks ();
}
mark_used (d);
return build_call (d, void_type_node, NULL_TREE);
}
static tree
throw_bad_cast ()
{
return call_void_fn ("__throw_bad_cast");
}
static tree
throw_bad_typeid ()
{
return call_void_fn ("__throw_bad_typeid");
}
tree
get_tinfo_fn_dynamic (exp)
tree exp;
{
tree type;
if (exp == error_mark_node)
return error_mark_node;
if (type_unknown_p (exp))
{
error ("typeid of overloaded function");
return error_mark_node;
}
type = TREE_TYPE (exp);
if (TREE_CODE (type) == REFERENCE_TYPE)
type = TREE_TYPE (type);
type = TYPE_MAIN_VARIANT (type);
if (TYPE_SIZE (complete_type (type)) == NULL_TREE)
{
cp_error ("taking typeid of incomplete type `%T'", type);
return error_mark_node;
}
if (TYPE_VIRTUAL_P (type) && ! resolves_to_fixed_type_p (exp, 0))
{
tree t;
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 (! 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);
TREE_TYPE (t) = build_pointer_type (tinfo_fn_type);
return t;
}
return get_tinfo_fn (TYPE_MAIN_VARIANT (type));
}
tree
build_typeid (exp)
tree exp;
{
exp = get_tinfo_fn_dynamic (exp);
exp = build_call (exp, TREE_TYPE (tinfo_fn_type), NULL_TREE);
return convert_from_reference (exp);
}
tree
build_x_typeid (exp)
tree exp;
{
tree cond = NULL_TREE;
tree type;
int nonnull;
if (! flag_rtti)
{
error ("cannot use typeid with -fno-rtti");
return error_mark_node;
}
if (TYPE_SIZE (type_info_type_node) == NULL_TREE)
{
error ("must #include <typeinfo> before using typeid");
return error_mark_node;
}
if (processing_template_decl)
return build_min_nt (TYPEID_EXPR, exp);
if (TREE_CODE (exp) == INDIRECT_REF
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
&& TYPE_VIRTUAL_P (TREE_TYPE (exp))
&& ! resolves_to_fixed_type_p (exp, &nonnull)
&& ! nonnull)
{
exp = stabilize_reference (exp);
cond = cp_convert (boolean_type_node, TREE_OPERAND (exp, 0));
}
exp = get_tinfo_fn_dynamic (exp);
if (exp == error_mark_node)
return error_mark_node;
type = TREE_TYPE (tinfo_fn_type);
exp = build_call (exp, type, NULL_TREE);
if (cond)
{
tree bad = throw_bad_typeid ();
bad = build_compound_expr
(expr_tree_cons (NULL_TREE, bad, build_expr_list
(NULL_TREE, cp_convert (type, integer_zero_node))));
exp = build (COND_EXPR, type, cond, exp, bad);
}
return convert_from_reference (exp);
}
#ifdef NEXT_SEMANTICS
void
ti_public_extern_bits ( tdecl, type )
tree tdecl;
tree type;
{
if (TYPE_VIRTUAL_P (type))
{
tree vtdcl = CLASSTYPE_VTABLE_DECL( type );
if (vtdcl)
{
TREE_PUBLIC (tdecl) = TREE_PUBLIC (vtdcl);
DECL_EXTERNAL (tdecl) = DECL_EXTERNAL (vtdcl);
return;
}
else
{
TREE_PUBLIC (tdecl) = 1;
DECL_EXTERNAL (tdecl) = 1;
return;
}
}
TREE_PUBLIC (tdecl) = 0;
DECL_EXTERNAL (tdecl) = 0;
}
#endif
static tree
get_tinfo_var (type)
tree type;
{
tree tname = build_overload_with_type (get_identifier ("__ti"), type);
tree tdecl, arrtype;
int size;
if (IDENTIFIER_GLOBAL_VALUE (tname))
return IDENTIFIER_GLOBAL_VALUE (tname);
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_USES_COMPLEX_INHERITANCE (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;
push_obstacks (&permanent_obstack, &permanent_obstack);
arrtype = build_cplus_array_type
(unsigned_char_type_node,
build_index_type (size_int (size / BITS_PER_UNIT - 1)));
tdecl = build_decl (VAR_DECL, tname, arrtype);
#ifdef NEXT_SEMANTICS
#ifdef __MAYBE_COALESCE_RTTI_VAR_P
if (__MAYBE_COALESCE_RTTI_VAR_P (tdecl))
{
MARK_RTTI_VAR_COALESCED (tdecl);
TREE_PUBLIC (tdecl) = 1;
DECL_EXTERNAL (tdecl) = 0;
}
else
#endif
ti_public_extern_bits (tdecl, type);
TREE_STATIC (tdecl) = 1;
DECL_COMMON (tdecl) = 0;
TREE_USED (tdecl) = 1;
DECL_ALIGN (tdecl) = TYPE_ALIGN (ptr_type_node);
#else
TREE_PUBLIC (tdecl) = 1;
DECL_EXTERNAL (tdecl) = 1;
DECL_COMMON (tdecl) = 1;
#endif
DECL_ARTIFICIAL (tdecl) = 1;
pushdecl_top_level (tdecl);
cp_finish_decl (tdecl, NULL_TREE, NULL_TREE, 0, 0);
pop_obstacks ();
return tdecl;
}
tree
get_tinfo_fn (type)
tree type;
{
tree name;
tree d;
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_fn_id, type);
if (IDENTIFIER_GLOBAL_VALUE (name))
return IDENTIFIER_GLOBAL_VALUE (name);
push_obstacks (&permanent_obstack, &permanent_obstack);
d = build_lang_decl (FUNCTION_DECL, name, tinfo_fn_type);
DECL_EXTERNAL (d) = 1;
TREE_PUBLIC (d) = 1;
DECL_ARTIFICIAL (d) = 1;
#ifdef MARK_RTTI_FUNC_COALESCED
MARK_RTTI_FUNC_COALESCED (d);
#endif
#if defined (DECL_MARK_INIT_SEGMENT)
DECL_MARK_INIT_SEGMENT (d);
#endif
DECL_NOT_REALLY_EXTERN (d) = 1;
SET_DECL_TINFO_FN_P (d);
TREE_TYPE (name) = copy_to_permanent (type);
pushdecl_top_level (d);
make_function_rtl (d);
mark_used (d);
mark_inline_for_output (d);
pop_obstacks ();
return d;
}
tree
get_typeid_1 (type)
tree type;
{
tree t;
t = build_call
(get_tinfo_fn (type), TREE_TYPE (tinfo_fn_type), NULL_TREE);
return convert_from_reference (t);
}
tree
get_typeid (type)
tree type;
{
if (type == error_mark_node)
return error_mark_node;
if (TYPE_SIZE (type_info_type_node) == NULL_TREE)
{
error ("must #include <typeinfo> before using typeid");
return error_mark_node;
}
if (! flag_rtti)
error ("requesting typeid with -fno-rtti");
if (processing_template_decl)
return build_min_nt (TYPEID_EXPR, type);
if (TREE_CODE (type) == REFERENCE_TYPE)
type = TREE_TYPE (type);
type = TYPE_MAIN_VARIANT (type);
if (TYPE_SIZE (complete_type (type)) == NULL_TREE)
{
cp_error ("taking typeid of incomplete type `%T'", type);
return error_mark_node;
}
return get_typeid_1 (type);
}
static tree
ifnonnull (test, result)
tree test, result;
{
return build (COND_EXPR, TREE_TYPE (result),
build (EQ_EXPR, boolean_type_node, test, integer_zero_node),
cp_convert (TREE_TYPE (result), integer_zero_node),
result);
}
static tree
build_dynamic_cast_1 (type, expr)
tree type, expr;
{
enum tree_code tc = TREE_CODE (type);
tree exprtype;
enum tree_code ec;
tree dcast_fn;
tree old_expr = expr;
if (TREE_CODE (expr) == OFFSET_REF)
expr = resolve_offset_ref (expr);
exprtype = TREE_TYPE (expr);
assert (exprtype != NULL_TREE);
ec = TREE_CODE (exprtype);
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 (complete_type (TREE_TYPE (exprtype))) == NULL_TREE)
goto fail;
if (!at_least_as_qualified_p (TREE_TYPE (type),
TREE_TYPE (exprtype)))
goto fail;
if (TYPE_MAIN_VARIANT (TREE_TYPE (type)) == void_type_node)
break;
case REFERENCE_TYPE:
if (TREE_CODE (TREE_TYPE (type)) != RECORD_TYPE)
goto fail;
if (TYPE_SIZE (complete_type (TREE_TYPE (type))) == NULL_TREE)
goto fail;
break;
default:
goto fail;
}
if (ec == RECORD_TYPE)
{
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 (complete_type (TREE_TYPE (exprtype))) == NULL_TREE)
goto fail;
if (!at_least_as_qualified_p (TREE_TYPE (type),
TREE_TYPE (exprtype)))
goto fail;
}
{
int distance;
tree path;
distance = get_base_distance (TREE_TYPE (type), TREE_TYPE (exprtype), 1,
&path);
if (distance == -2)
{
cp_error ("dynamic_cast from `%T' to ambiguous base class `%T'",
TREE_TYPE (exprtype), TREE_TYPE (type));
return error_mark_node;
}
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);
}
if (TYPE_VIRTUAL_P (TREE_TYPE (exprtype)))
{
tree expr1;
if (tc == POINTER_TYPE
&& TYPE_MAIN_VARIANT (TREE_TYPE (type)) == void_type_node)
{
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);
expr = save_expr (expr);
expr1 = build_headof (expr);
if (TREE_TYPE (expr1) != type)
expr1 = build1 (NOP_EXPR, type, expr1);
return ifnonnull (expr, expr1);
}
else
{
tree retval;
tree result, td1, td2, td3, elems, expr2;
if (ec == REFERENCE_TYPE)
{
if (TREE_CODE (old_expr) == VAR_DECL
&& TREE_CODE (TREE_TYPE (old_expr)) == RECORD_TYPE)
{
cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
old_expr, type);
return throw_bad_cast ();
}
}
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",
op, type);
retval = build_int_2 (0, 0);
TREE_TYPE (retval) = type;
return retval;
}
}
expr = save_expr (expr);
expr1 = expr;
if (tc == REFERENCE_TYPE)
expr1 = build_unary_op (ADDR_EXPR, expr1, 0);
expr2 = build_headof (expr1);
if (ec == POINTER_TYPE)
td1 = get_tinfo_fn_dynamic (build_indirect_ref (expr, NULL_PTR));
else
td1 = get_tinfo_fn_dynamic (expr);
td1 = decay_conversion (td1);
td2 = decay_conversion
(get_tinfo_fn (TYPE_MAIN_VARIANT (TREE_TYPE (type))));
td3 = decay_conversion
(get_tinfo_fn (TYPE_MAIN_VARIANT (TREE_TYPE (exprtype))));
elems = tree_cons
(NULL_TREE, td1, tree_cons
(NULL_TREE, td2, tree_cons
(NULL_TREE, build_int_2 (1, 0), tree_cons
(NULL_TREE, expr2, tree_cons
(NULL_TREE, td3, tree_cons
(NULL_TREE, expr1, NULL_TREE))))));
dcast_fn = get_identifier ("__dynamic_cast");
if (IDENTIFIER_GLOBAL_VALUE (dcast_fn))
dcast_fn = IDENTIFIER_GLOBAL_VALUE (dcast_fn);
else
{
tree tmp;
push_obstacks (&permanent_obstack, &permanent_obstack);
tmp = tree_cons
(NULL_TREE, TREE_TYPE (td1), tree_cons
(NULL_TREE, TREE_TYPE (td1), tree_cons
(NULL_TREE, integer_type_node, tree_cons
(NULL_TREE, ptr_type_node, tree_cons
(NULL_TREE, TREE_TYPE (td1), tree_cons
(NULL_TREE, ptr_type_node, void_list_node))))));
tmp = build_function_type (ptr_type_node, tmp);
dcast_fn = build_lang_decl (FUNCTION_DECL, dcast_fn, tmp);
DECL_EXTERNAL (dcast_fn) = 1;
TREE_PUBLIC (dcast_fn) = 1;
DECL_ARTIFICIAL (dcast_fn) = 1;
pushdecl_top_level (dcast_fn);
make_function_rtl (dcast_fn);
pop_obstacks ();
}
mark_used (dcast_fn);
result = build_call
(dcast_fn, TREE_TYPE (TREE_TYPE (dcast_fn)), elems);
if (tc == REFERENCE_TYPE)
{
expr1 = throw_bad_cast ();
expr1 = build_compound_expr
(expr_tree_cons (NULL_TREE, expr1,
build_expr_list (NULL_TREE, cp_convert (type, integer_zero_node))));
TREE_TYPE (expr1) = type;
result = save_expr (result);
return build (COND_EXPR, type, result, result, expr1);
}
result = cp_convert (type, result);
return ifnonnull (expr, result);
}
}
fail:
cp_error ("cannot dynamic_cast `%E' (of type `%#T') to type `%#T'",
expr, exprtype, type);
return error_mark_node;
}
tree
build_dynamic_cast (type, expr)
tree type, expr;
{
if (type == error_mark_node || expr == error_mark_node)
return error_mark_node;
if (processing_template_decl)
return build_min (DYNAMIC_CAST_EXPR, copy_to_permanent (type), expr);
return convert_from_reference (build_dynamic_cast_1 (type, expr));
}
extern tree const_string_type_node;
static void
expand_si_desc (tdecl, type)
tree tdecl;
tree type;
{
tree t, elems, fn;
const char *name = build_overload_name (type, 1, 1);
tree name_string = combine_strings (build_string (strlen (name)+1, name));
type = BINFO_TYPE (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), 0));
expand_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;
push_obstacks (&permanent_obstack, &permanent_obstack);
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)));
tmp = build_function_type (void_type_node, tmp);
fn = build_lang_decl (FUNCTION_DECL, fn, tmp);
DECL_EXTERNAL (fn) = 1;
TREE_PUBLIC (fn) = 1;
DECL_ARTIFICIAL (fn) = 1;
pushdecl_top_level (fn);
make_function_rtl (fn);
pop_obstacks ();
}
mark_used (fn);
fn = build_call (fn, TREE_TYPE (TREE_TYPE (fn)), elems);
expand_expr_stmt (fn);
}
static void
expand_class_desc (tdecl, type)
tree tdecl;
tree type;
{
tree name_string;
tree fn, tmp;
const char *name;
int i = CLASSTYPE_N_BASECLASSES (type);
int base_cnt = 0;
tree binfos = TYPE_BINFO_BASETYPES (type);
#if 0
tree vb = CLASSTYPE_VBASECLASSES (type);
int n_base = i;
#endif
tree base, elems, access, offset, isvir;
tree elt, elts = NULL_TREE;
static tree base_info_type_node;
if (base_info_type_node == NULL_TREE)
{
tree fields [4];
push_obstacks (&permanent_obstack, &permanent_obstack);
base_info_type_node = make_lang_type (RECORD_TYPE);
fields [0] = build_lang_field_decl
(FIELD_DECL, NULL_TREE,
build_pointer_type (build_qualified_type
(type_info_type_node,
TYPE_QUAL_CONST)));
fields [1] = build_lang_field_decl
(FIELD_DECL, NULL_TREE, unsigned_intSI_type_node);
DECL_BIT_FIELD (fields[1]) = 1;
DECL_FIELD_SIZE (fields[1]) = 29;
fields [2] = build_lang_field_decl
(FIELD_DECL, NULL_TREE, boolean_type_node);
DECL_BIT_FIELD (fields[2]) = 1;
DECL_FIELD_SIZE (fields[2]) = 1;
fields [3] = build_lang_field_decl
(FIELD_DECL, NULL_TREE, integer_type_node);
DECL_BIT_FIELD (fields[3]) = 1;
DECL_FIELD_SIZE (fields[3]) = 2;
finish_builtin_type (base_info_type_node, "__base_info", fields,
3, ptr_type_node);
pop_obstacks ();
}
while (--i >= 0)
{
tree binfo = TREE_VEC_ELT (binfos, i);
expand_expr_stmt (get_typeid_1 (BINFO_TYPE (binfo)));
base = decay_conversion (get_tinfo_var (BINFO_TYPE (binfo)));
if (TREE_VIA_VIRTUAL (binfo))
{
tree t = BINFO_TYPE (binfo);
const char *name;
tree field;
FORMAT_VBASE_NAME (name, 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));
offset = convert (sizetype, offset);
}
else
offset = BINFO_OFFSET (binfo);
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_info_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 = expr_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 = expr_tree_cons (NULL_TREE, base, base_list);
isvir_list = expr_tree_cons (NULL_TREE, isvir, isvir_list);
acc_list = expr_tree_cons (NULL_TREE, access, acc_list);
off_list = expr_tree_cons (NULL_TREE, offset, off_list);
base_cnt++;
vb = TREE_CHAIN (vb);
}
#endif
name = build_overload_name (type, 1, 1);
name_string = combine_strings (build_string (strlen (name)+1, name));
{
tree arrtype = build_array_type (base_info_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
{
push_obstacks (&permanent_obstack, &permanent_obstack);
tmp = tree_cons
(NULL_TREE, ptr_type_node, tree_cons
(NULL_TREE, const_string_type_node, tree_cons
(NULL_TREE, build_pointer_type (base_info_type_node), tree_cons
(NULL_TREE, sizetype, void_list_node))));
tmp = build_function_type (void_type_node, tmp);
fn = build_lang_decl (FUNCTION_DECL, fn, tmp);
DECL_EXTERNAL (fn) = 1;
TREE_PUBLIC (fn) = 1;
DECL_ARTIFICIAL (fn) = 1;
pushdecl_top_level (fn);
make_function_rtl (fn);
pop_obstacks ();
}
mark_used (fn);
fn = build_call (fn, TREE_TYPE (TREE_TYPE (fn)), elems);
expand_expr_stmt (fn);
}
static void
expand_ptr_desc (tdecl, type)
tree tdecl;
tree type;
{
tree t, elems, fn;
const char *name = build_overload_name (type, 1, 1);
tree name_string = combine_strings (build_string (strlen (name)+1, name));
type = TREE_TYPE (type);
expand_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;
push_obstacks (&permanent_obstack, &permanent_obstack);
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)));
tmp = build_function_type (void_type_node, tmp);
fn = build_lang_decl (FUNCTION_DECL, fn, tmp);
DECL_EXTERNAL (fn) = 1;
TREE_PUBLIC (fn) = 1;
DECL_ARTIFICIAL (fn) = 1;
pushdecl_top_level (fn);
make_function_rtl (fn);
pop_obstacks ();
}
mark_used (fn);
fn = build_call (fn, TREE_TYPE (TREE_TYPE (fn)), elems);
expand_expr_stmt (fn);
}
static void
expand_attr_desc (tdecl, type)
tree tdecl;
tree type;
{
tree elems, t, fn;
const char *name = build_overload_name (type, 1, 1);
tree name_string = combine_strings (build_string (strlen (name)+1, name));
tree attrval = build_int_2 (TYPE_QUALS (type), 0);
expand_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, expr_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;
push_obstacks (&permanent_obstack, &permanent_obstack);
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))));
tmp = build_function_type (void_type_node, tmp);
fn = build_lang_decl (FUNCTION_DECL, fn, tmp);
DECL_EXTERNAL (fn) = 1;
TREE_PUBLIC (fn) = 1;
DECL_ARTIFICIAL (fn) = 1;
pushdecl_top_level (fn);
make_function_rtl (fn);
pop_obstacks ();
}
mark_used (fn);
fn = build_call (fn, TREE_TYPE (TREE_TYPE (fn)), elems);
expand_expr_stmt (fn);
}
static void
expand_generic_desc (tdecl, type, fnname)
tree tdecl;
tree type;
const char *fnname;
{
const char *name = build_overload_name (type, 1, 1);
tree name_string = combine_strings (build_string (strlen (name)+1, name));
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;
push_obstacks (&permanent_obstack, &permanent_obstack);
tmp = tree_cons
(NULL_TREE, ptr_type_node, tree_cons
(NULL_TREE, const_string_type_node, void_list_node));
tmp = build_function_type (void_type_node, tmp);
fn = build_lang_decl (FUNCTION_DECL, fn, tmp);
DECL_EXTERNAL (fn) = 1;
TREE_PUBLIC (fn) = 1;
DECL_ARTIFICIAL (fn) = 1;
pushdecl_top_level (fn);
make_function_rtl (fn);
pop_obstacks ();
}
mark_used (fn);
fn = build_call (fn, TREE_TYPE (TREE_TYPE (fn)), elems);
expand_expr_stmt (fn);
}
void
synthesize_tinfo_fn (fndecl)
tree fndecl;
{
tree type;
tree tmp, addr, tdecl;
if (at_eof)
{
import_export_decl (fndecl);
if (DECL_REALLY_EXTERN (fndecl))
return;
}
type = TREE_TYPE (DECL_NAME (fndecl));
tdecl = get_tinfo_var (type);
#ifdef MARK_RTTI_FUNC_COALESCED
MARK_RTTI_FUNC_COALESCED (fndecl);
#endif
#ifdef NEXT_SEMANTICS
if (! TREE_ASM_WRITTEN (tdecl))
{
#ifdef __MAYBE_COALESCE_RTTI_VAR_P
if (__MAYBE_COALESCE_RTTI_VAR_P (tdecl))
{
MARK_RTTI_VAR_COALESCED (tdecl);
TREE_PUBLIC (tdecl) = 1;
DECL_COMMON (tdecl) = 1;
DECL_EXTERNAL (tdecl) = 1;
}
else
#endif
DECL_COMMON (tdecl) = 0;
TREE_STATIC (tdecl) = 1;
TREE_USED (tdecl) = 1;
DECL_ALIGN (tdecl) = TYPE_ALIGN (ptr_type_node);
cp_finish_decl (tdecl, NULL_TREE, NULL_TREE, 0, 0);
#if defined (DECL_MARK_INIT_SEGMENT)
DECL_MARK_INIT_SEGMENT (tdecl);
#endif
}
#else
DECL_COMMON (tdecl) = 1;
DECL_EXTERNAL (tdecl) = 0;
TREE_STATIC (tdecl) = 1;
TREE_USED (tdecl) = 1;
DECL_ALIGN (tdecl) = TYPE_ALIGN (ptr_type_node);
cp_finish_decl (tdecl, NULL_TREE, NULL_TREE, 0, 0);
#endif
start_function (NULL_TREE, fndecl, NULL_TREE, 1);
store_parm_decls ();
clear_last_expr ();
push_momentary ();
addr = decay_conversion (tdecl);
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);
expand_start_cond (tmp, 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_USES_COMPLEX_INHERITANCE (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);
expand_end_cond ();
tmp = cp_convert (build_pointer_type (type_info_type_node), addr);
tmp = build_indirect_ref (tmp, 0);
c_expand_return (tmp);
finish_function (lineno, 0, 0);
}