1 /* RunTime Type Identification
2 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000
3 Free Software Foundation, Inc.
4 Mostly written by Jason Merrill (jason@cygnus.com).
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
34 #define INT_TYPE_SIZE BITS_PER_WORD
37 /* Accessors for the type_info objects. We need to remember several things
38 about each of the type_info types. The global tree nodes such as
39 bltn_desc_type_node are TREE_LISTs, and these macros are used to access
40 the required information. */
41 /* The RECORD_TYPE of a type_info derived class. */
42 #define TINFO_PSEUDO_TYPE(NODE) TREE_TYPE (NODE)
43 /* The VAR_DECL of the vtable for the type_info derived class. */
44 #define TINFO_VTABLE_DECL(NODE) TREE_VALUE (NODE)
46 extern struct obstack permanent_obstack;
48 static tree build_headof_sub PARAMS((tree));
49 static tree build_headof PARAMS((tree));
50 static tree get_tinfo_var PARAMS((tree));
51 static tree ifnonnull PARAMS((tree, tree));
52 static tree tinfo_name PARAMS((tree));
53 static tree get_base_offset PARAMS((tree, tree));
54 static tree build_dynamic_cast_1 PARAMS((tree, tree));
55 static void expand_si_desc PARAMS((tree, tree));
56 static void expand_class_desc PARAMS((tree, tree));
57 static void expand_attr_desc PARAMS((tree, tree));
58 static void expand_ptr_desc PARAMS((tree, tree));
59 static void expand_generic_desc PARAMS((tree, tree, const char *));
60 static tree throw_bad_cast PARAMS((void));
61 static tree throw_bad_typeid PARAMS((void));
62 static tree get_tinfo_decl_dynamic PARAMS((tree));
63 static tree tinfo_from_decl PARAMS((tree));
64 static int qualifier_flags PARAMS((tree));
65 static int target_incomplete_p PARAMS((tree));
66 static tree tinfo_base_init PARAMS((tree, tree));
67 static tree generic_initializer PARAMS((tree, tree));
68 static tree ptr_initializer PARAMS((tree, tree, int *));
69 static tree ptm_initializer PARAMS((tree, tree, int *));
70 static tree dfs_class_hint_mark PARAMS ((tree, void *));
71 static tree dfs_class_hint_unmark PARAMS ((tree, void *));
72 static int class_hint_flags PARAMS((tree));
73 static tree class_initializer PARAMS((tree, tree, tree));
74 static tree synthesize_tinfo_var PARAMS((tree, tree));
75 static tree create_real_tinfo_var PARAMS((tree, tree, tree, int));
76 static tree create_pseudo_type_info PARAMS((const char *, int, ...));
77 static tree get_vmi_pseudo_type_info PARAMS((int));
78 static void create_tinfo_types PARAMS((void));
80 static int doing_runtime = 0;
83 init_rtti_processing ()
86 push_namespace (get_identifier ("std"));
87 type_info_type_node = xref_tag
88 (class_type_node, get_identifier ("type_info"), 1);
91 if (!new_abi_rtti_p ())
93 tinfo_decl_id = get_identifier ("__tf");
94 tinfo_decl_type = build_function_type
97 (type_info_type_node, TYPE_QUAL_CONST)),
99 tinfo_var_id = get_identifier ("__ti");
103 /* FIXME: These identifier prefixes are not set in stone yet. */
104 tinfo_decl_id = get_identifier ("__ti");
105 tinfo_var_id = get_identifier ("__tn");
106 tinfo_decl_type = build_qualified_type
107 (type_info_type_node, TYPE_QUAL_CONST);
111 /* Given a pointer to an object with at least one virtual table
112 pointer somewhere, return a pointer to a possible sub-object that
113 has a virtual table pointer in it that is the vtable parent for
117 build_headof_sub (exp)
120 tree type = TREE_TYPE (TREE_TYPE (exp));
121 tree basetype = CLASSTYPE_RTTI (type);
122 tree binfo = get_binfo (basetype, type, 0);
124 exp = convert_pointer_to_real (binfo, exp);
128 /* Given the expression EXP of type `class *', return the head of the
129 object pointed to by EXP with type cv void*, if the class has any
130 virtual functions (TYPE_POLYMORPHIC_P), else just return the
137 tree type = TREE_TYPE (exp);
142 my_friendly_assert (TREE_CODE (type) == POINTER_TYPE, 20000112);
143 type = TREE_TYPE (type);
145 if (!TYPE_POLYMORPHIC_P (type))
147 if (CLASSTYPE_COM_INTERFACE (type))
149 cp_error ("RTTI not supported for COM interface type `%T'", type);
150 return error_mark_node;
153 /* If we don't have rtti stuff, get to a sub-object that does. */
154 if (!CLASSTYPE_VFIELDS (TREE_TYPE (TREE_TYPE (exp))))
155 exp = build_headof_sub (exp);
157 /* We use this a couple of times below, protect it. */
158 exp = save_expr (exp);
160 /* Under the new ABI, the offset-to-top field is at index -2 from
162 if (new_abi_rtti_p ())
163 index = build_int_2 (-2, -1);
164 /* But under the old ABI, it is at offset zero. */
166 index = integer_zero_node;
168 aref = build_vtbl_ref (build_indirect_ref (exp, NULL_PTR), index);
170 if (flag_vtable_thunks)
173 offset = build_component_ref (aref, delta_identifier, NULL_TREE, 0);
175 type = build_qualified_type (ptr_type_node,
176 CP_TYPE_QUALS (TREE_TYPE (exp)));
177 return build (PLUS_EXPR, type, exp,
178 cp_convert (ptrdiff_type_node, offset));
181 /* Get a bad_cast node for the program to throw...
183 See libstdc++/exception.cc for __throw_bad_cast */
188 tree fn = get_identifier ("__throw_bad_cast");
189 if (IDENTIFIER_GLOBAL_VALUE (fn))
190 fn = IDENTIFIER_GLOBAL_VALUE (fn);
192 fn = push_throw_library_fn (fn, build_function_type (ptr_type_node,
195 return build_call (fn, NULL_TREE);
201 tree fn = get_identifier ("__throw_bad_typeid");
202 if (IDENTIFIER_GLOBAL_VALUE (fn))
203 fn = IDENTIFIER_GLOBAL_VALUE (fn);
206 tree t = build_qualified_type (type_info_type_node, TYPE_QUAL_CONST);
207 t = build_function_type (build_reference_type (t), void_list_node);
208 fn = push_throw_library_fn (fn, t);
211 return build_call (fn, NULL_TREE);
214 /* Return a pointer to type_info function associated with the expression EXP.
215 If EXP is a reference to a polymorphic class, return the dynamic type;
216 otherwise return the static type of the expression. */
219 get_tinfo_decl_dynamic (exp)
224 if (exp == error_mark_node)
225 return error_mark_node;
227 type = TREE_TYPE (exp);
229 /* peel back references, so they match. */
230 if (TREE_CODE (type) == REFERENCE_TYPE)
231 type = TREE_TYPE (type);
233 /* Peel off cv qualifiers. */
234 type = TYPE_MAIN_VARIANT (type);
236 if (!VOID_TYPE_P (type))
237 type = complete_type_or_else (type, exp);
240 return error_mark_node;
242 /* If exp is a reference to polymorphic type, get the real type_info. */
243 if (TYPE_POLYMORPHIC_P (type) && ! resolves_to_fixed_type_p (exp, 0))
245 /* build reference to type_info from vtable. */
250 error ("taking dynamic typeid of object with -fno-rtti");
251 if (CLASSTYPE_COM_INTERFACE (type))
253 cp_error ("RTTI not supported for COM interface type `%T'", type);
254 return error_mark_node;
257 /* If we don't have rtti stuff, get to a sub-object that does. */
258 if (! CLASSTYPE_VFIELDS (type))
260 exp = build_unary_op (ADDR_EXPR, exp, 0);
261 exp = build_headof_sub (exp);
262 exp = build_indirect_ref (exp, NULL_PTR);
265 /* The RTTI information is always in the vtable, but it's at
266 different indices depending on the ABI. */
267 if (new_abi_rtti_p ())
268 index = minus_one_node;
269 else if (flag_vtable_thunks)
270 index = integer_one_node;
272 index = integer_zero_node;
273 t = build_vfn_ref ((tree *) 0, exp, index);
274 TREE_TYPE (t) = build_pointer_type (tinfo_decl_type);
278 /* otherwise return the type_info for the static type of the expr. */
279 exp = get_tinfo_decl (TYPE_MAIN_VARIANT (type));
280 return build_unary_op (ADDR_EXPR, exp, 0);
287 tree cond = NULL_TREE;
292 error ("cannot use typeid with -fno-rtti");
293 return error_mark_node;
296 if (!COMPLETE_TYPE_P (type_info_type_node))
298 error ("must #include <typeinfo> before using typeid");
299 return error_mark_node;
302 if (processing_template_decl)
303 return build_min_nt (TYPEID_EXPR, exp);
305 if (TREE_CODE (exp) == INDIRECT_REF
306 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
307 && TYPE_POLYMORPHIC_P (TREE_TYPE (exp))
308 && ! resolves_to_fixed_type_p (exp, &nonnull)
311 exp = stabilize_reference (exp);
312 cond = cp_convert (boolean_type_node, TREE_OPERAND (exp, 0));
315 exp = get_tinfo_decl_dynamic (exp);
317 if (exp == error_mark_node)
318 return error_mark_node;
320 exp = tinfo_from_decl (exp);
324 tree bad = throw_bad_typeid ();
326 exp = build (COND_EXPR, TREE_TYPE (exp), cond, exp, bad);
329 return convert_from_reference (exp);
336 tree tname = build_overload_with_type (tinfo_var_id, type);
340 my_friendly_assert (!new_abi_rtti_p (), 20000118);
341 if (IDENTIFIER_GLOBAL_VALUE (tname))
342 return IDENTIFIER_GLOBAL_VALUE (tname);
344 /* Figure out how much space we need to allocate for the type_info object.
345 If our struct layout or the type_info classes are changed, this will
346 need to be modified. */
347 if (TYPE_QUALS (type) != TYPE_UNQUALIFIED)
348 size = 3 * POINTER_SIZE + INT_TYPE_SIZE;
349 else if (TREE_CODE (type) == POINTER_TYPE
350 && ! (TREE_CODE (TREE_TYPE (type)) == OFFSET_TYPE
351 || TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE))
352 size = 3 * POINTER_SIZE;
353 else if (IS_AGGR_TYPE (type))
355 if (CLASSTYPE_N_BASECLASSES (type) == 0)
356 size = 2 * POINTER_SIZE;
357 else if (! TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type)
359 (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), 0))))
360 size = 3 * POINTER_SIZE;
362 size = 3 * POINTER_SIZE + TYPE_PRECISION (sizetype);
365 size = 2 * POINTER_SIZE;
367 /* The type for a character array of the appropriate size. */
368 arrtype = build_cplus_array_type
369 (unsigned_char_type_node,
370 build_index_type (size_int (size / BITS_PER_UNIT - 1)));
372 return declare_global_var (tname, arrtype);
375 /* Generate the NTBS name of a type. */
384 name = mangle_type_string (type);
386 name = build_overload_name (type, 1, 1);
387 name_string = combine_strings (build_string (strlen (name) + 1, name));
391 /* Returns a decl for a function or variable which can be used to obtain a
392 type_info object for TYPE. The old-abi uses functions, the new-abi
393 uses the type_info object directly. You can take the address of the
394 returned decl, to save the decl. To use the decl call
395 tinfo_from_decl. You must arrange that the decl is mark_used, if
396 actually use it --- decls in vtables are only used if the vtable is
400 get_tinfo_decl (type)
406 if (TREE_CODE (type) == OFFSET_TYPE)
407 type = TREE_TYPE (type);
408 if (TREE_CODE (type) == METHOD_TYPE)
409 type = build_function_type (TREE_TYPE (type),
410 TREE_CHAIN (TYPE_ARG_TYPES (type)));
413 name = mangle_typeinfo_for_type (type);
415 name = build_overload_with_type (tinfo_decl_id, type);
417 d = IDENTIFIER_GLOBAL_VALUE (name);
420 else if (!new_abi_rtti_p ())
422 /* The tinfo decl is a function returning a reference to the
424 d = push_library_fn (name, tinfo_decl_type);
425 DECL_NOT_REALLY_EXTERN (d) = 1;
426 SET_DECL_TINFO_FN_P (d);
427 TREE_TYPE (name) = type;
432 /* The tinfo decl is the type_info object itself. We make all
433 tinfo objects look as type_info, even though they will end up
434 being a subclass of that when emitted. This means the we'll
435 erroneously think we know the dynamic type -- be careful in the
437 d = build_lang_decl (VAR_DECL, name, tinfo_decl_type);
439 DECL_ARTIFICIAL (d) = 1;
440 DECL_ALIGN (d) = TYPE_ALIGN (ptr_type_node);
441 DECL_USER_ALIGN (d) = 0;
442 TREE_READONLY (d) = 1;
444 DECL_EXTERNAL (d) = 1;
447 DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
448 cp_finish_decl (d, NULL_TREE, NULL_TREE, 0);
450 pushdecl_top_level (d);
451 /* Remember the type it is for. */
452 TREE_TYPE (name) = type;
453 TREE_USED (name) = 1;
458 /* Given an expr produced by get_tinfo_decl, return an expr which
459 produces a reference to the type_info object. */
462 tinfo_from_decl (expr)
467 if (!new_abi_rtti_p ())
468 t = build_call (expr, NULL_TREE);
469 else if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
470 t = build_indirect_ref (expr, NULL);
483 t = get_tinfo_decl (type);
484 t = tinfo_from_decl (t);
485 return convert_from_reference (t);
488 /* Return the type_info object for TYPE. */
494 if (type == error_mark_node)
495 return error_mark_node;
497 if (!COMPLETE_TYPE_P (type_info_type_node))
499 error ("must #include <typeinfo> before using typeid");
500 return error_mark_node;
503 if (processing_template_decl)
504 return build_min_nt (TYPEID_EXPR, type);
506 /* If the type of the type-id is a reference type, the result of the
507 typeid expression refers to a type_info object representing the
509 if (TREE_CODE (type) == REFERENCE_TYPE)
510 type = TREE_TYPE (type);
512 /* The top-level cv-qualifiers of the lvalue expression or the type-id
513 that is the operand of typeid are always ignored. */
514 type = TYPE_MAIN_VARIANT (type);
516 if (!VOID_TYPE_P (type))
517 type = complete_type_or_else (type, NULL_TREE);
520 return error_mark_node;
522 return get_typeid_1 (type);
525 /* Check whether TEST is null before returning RESULT. If TEST is used in
526 RESULT, it must have previously had a save_expr applied to it. */
529 ifnonnull (test, result)
532 return build (COND_EXPR, TREE_TYPE (result),
533 build (EQ_EXPR, boolean_type_node, test, integer_zero_node),
534 cp_convert (TREE_TYPE (result), integer_zero_node),
538 /* Generate the constant expression describing where direct base BINFO
539 appears within the PARENT. How to interpret this expression depends on
540 details of the ABI, which the runtime must be aware of. */
543 get_base_offset (binfo, parent)
547 if (! TREE_VIA_VIRTUAL (binfo))
548 return BINFO_OFFSET (binfo);
549 else if (! vbase_offsets_in_vtable_p ())
555 FORMAT_VBASE_NAME (name, BINFO_TYPE (binfo));
556 field = lookup_field (parent, get_identifier (name), 0, 0);
557 result = byte_position (field);
559 if (DECL_CONTEXT (field) != parent)
561 /* The vbase pointer might be in a non-virtual base of PARENT.
562 * Adjust for the offset of that base in PARENT. */
565 get_base_distance (DECL_CONTEXT (field), parent, -1, &path);
566 result = build (PLUS_EXPR, TREE_TYPE (result),
567 result, BINFO_OFFSET (path));
568 result = fold (result);
573 /* Under the new ABI, we store the vtable offset at which
574 the virtual base offset can be found. */
575 return convert (sizetype,
576 BINFO_VPTR_FIELD (binfo_for_vbase (BINFO_TYPE (binfo),
581 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
585 build_dynamic_cast_1 (type, expr)
588 enum tree_code tc = TREE_CODE (type);
589 tree exprtype = TREE_TYPE (expr);
591 tree old_expr = expr;
592 const char *errstr = NULL;
594 /* T shall be a pointer or reference to a complete class type, or
595 `pointer to cv void''. */
599 if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
602 if (! IS_AGGR_TYPE (TREE_TYPE (type)))
604 errstr = "target is not pointer or reference to class";
607 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
609 errstr = "target is not pointer or reference to complete type";
615 errstr = "target is not pointer or reference";
619 if (TREE_CODE (expr) == OFFSET_REF)
621 expr = resolve_offset_ref (expr);
622 exprtype = TREE_TYPE (expr);
625 if (tc == POINTER_TYPE)
626 expr = convert_from_reference (expr);
627 else if (TREE_CODE (exprtype) != REFERENCE_TYPE)
629 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
630 exprtype = build_reference_type (exprtype);
631 expr = convert_to_reference (exprtype, expr, CONV_IMPLICIT,
632 LOOKUP_NORMAL, NULL_TREE);
635 exprtype = TREE_TYPE (expr);
637 if (tc == POINTER_TYPE)
639 /* If T is a pointer type, v shall be an rvalue of a pointer to
640 complete class type, and the result is an rvalue of type T. */
642 if (TREE_CODE (exprtype) != POINTER_TYPE)
644 errstr = "source is not a pointer";
647 if (! IS_AGGR_TYPE (TREE_TYPE (exprtype)))
649 errstr = "source is not a pointer to class";
652 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
654 errstr = "source is a pointer to incomplete type";
660 /* T is a reference type, v shall be an lvalue of a complete class
661 type, and the result is an lvalue of the type referred to by T. */
663 if (! IS_AGGR_TYPE (TREE_TYPE (exprtype)))
665 errstr = "source is not of class type";
668 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
670 errstr = "source is of incomplete class type";
676 /* The dynamic_cast operator shall not cast away constness. */
677 if (!at_least_as_qualified_p (TREE_TYPE (type),
678 TREE_TYPE (exprtype)))
680 errstr = "conversion casts away constness";
684 /* If *type is an unambiguous accessible base class of *exprtype,
685 convert statically. */
690 distance = get_base_distance (TREE_TYPE (type), TREE_TYPE (exprtype), 1,
695 cp_error ("dynamic_cast from `%T' to ambiguous base class `%T'",
696 TREE_TYPE (exprtype), TREE_TYPE (type));
697 return error_mark_node;
701 cp_error ("dynamic_cast from `%T' to private base class `%T'",
702 TREE_TYPE (exprtype), TREE_TYPE (type));
703 return error_mark_node;
708 expr = build_vbase_path (PLUS_EXPR, type, expr, path, 0);
709 if (TREE_CODE (exprtype) == POINTER_TYPE)
710 expr = non_lvalue (expr);
715 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
716 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype)))
719 /* if TYPE is `void *', return pointer to complete object. */
720 if (tc == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (type)))
722 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
723 if (TREE_CODE (expr) == ADDR_EXPR
724 && TREE_CODE (TREE_OPERAND (expr, 0)) == VAR_DECL
725 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == RECORD_TYPE)
726 return build1 (NOP_EXPR, type, expr);
728 /* Since expr is used twice below, save it. */
729 expr = save_expr (expr);
731 expr1 = build_headof (expr);
732 if (TREE_TYPE (expr1) != type)
733 expr1 = build1 (NOP_EXPR, type, expr1);
734 return ifnonnull (expr, expr1);
739 tree result, td2, td3, elems;
740 tree static_type, target_type, boff;
742 /* If we got here, we can't convert statically. Therefore,
743 dynamic_cast<D&>(b) (b an object) cannot succeed. */
744 if (tc == REFERENCE_TYPE)
746 if (TREE_CODE (old_expr) == VAR_DECL
747 && TREE_CODE (TREE_TYPE (old_expr)) == RECORD_TYPE)
749 tree expr = throw_bad_cast ();
750 cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
752 /* Bash it to the expected type. */
753 TREE_TYPE (expr) = type;
757 /* Ditto for dynamic_cast<D*>(&b). */
758 else if (TREE_CODE (expr) == ADDR_EXPR)
760 tree op = TREE_OPERAND (expr, 0);
761 if (TREE_CODE (op) == VAR_DECL
762 && TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE)
764 cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
766 retval = build_int_2 (0, 0);
767 TREE_TYPE (retval) = type;
772 target_type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
773 static_type = TYPE_MAIN_VARIANT (TREE_TYPE (exprtype));
774 td2 = build_unary_op (ADDR_EXPR, get_tinfo_decl (target_type), 0);
775 td3 = build_unary_op (ADDR_EXPR, get_tinfo_decl (static_type), 0);
777 /* Determine how T and V are related. */
778 boff = get_dynamic_cast_base_type (static_type, target_type);
780 /* Since expr is used twice below, save it. */
781 expr = save_expr (expr);
784 if (tc == REFERENCE_TYPE)
785 expr1 = build_unary_op (ADDR_EXPR, expr1, 0);
787 if (!new_abi_rtti_p ())
789 tree expr2 = build_headof (expr1);
792 if (tc == POINTER_TYPE)
793 td1 = build_indirect_ref (td1, NULL_PTR);
794 td1 = get_tinfo_decl_dynamic (td1);
797 (NULL_TREE, td1, tree_cons
798 (NULL_TREE, td2, tree_cons
799 (NULL_TREE, boff, tree_cons
800 (NULL_TREE, expr2, tree_cons
801 (NULL_TREE, td3, tree_cons
802 (NULL_TREE, expr1, NULL_TREE))))));
806 (NULL_TREE, expr1, tree_cons
807 (NULL_TREE, td3, tree_cons
808 (NULL_TREE, td2, tree_cons
809 (NULL_TREE, boff, NULL_TREE))));
811 dcast_fn = dynamic_cast_node;
816 tree ns = new_abi_rtti_p () ? abi_node : global_namespace;
819 push_nested_namespace (ns);
820 if (!new_abi_rtti_p ())
822 tinfo_ptr = build_pointer_type (tinfo_decl_type);
823 name = "__dynamic_cast_2";
825 (NULL_TREE, tinfo_ptr, tree_cons
826 (NULL_TREE, tinfo_ptr, tree_cons
827 (NULL_TREE, integer_type_node, tree_cons
828 (NULL_TREE, ptr_type_node, tree_cons
829 (NULL_TREE, tinfo_ptr, tree_cons
830 (NULL_TREE, ptr_type_node, void_list_node))))));
834 tinfo_ptr = xref_tag (class_type_node,
835 get_identifier ("__class_type_info"),
838 tinfo_ptr = build_pointer_type
839 (build_qualified_type
840 (tinfo_ptr, TYPE_QUAL_CONST));
841 name = "__dynamic_cast";
843 (NULL_TREE, const_ptr_type_node, tree_cons
844 (NULL_TREE, tinfo_ptr, tree_cons
845 (NULL_TREE, tinfo_ptr, tree_cons
846 (NULL_TREE, ptrdiff_type_node, void_list_node))));
848 tmp = build_function_type (ptr_type_node, tmp);
849 if (new_abi_rtti_p ())
850 /* We want its name mangling. */
851 dcast_fn = build_cp_library_fn_ptr (name, tmp);
853 dcast_fn = build_library_fn_ptr (name, tmp);
854 pop_nested_namespace (ns);
855 dynamic_cast_node = dcast_fn;
857 result = build_call (dcast_fn, elems);
859 if (tc == REFERENCE_TYPE)
861 tree bad = throw_bad_cast ();
863 result = save_expr (result);
864 return build (COND_EXPR, type, result, result, bad);
867 /* Now back to the type we want from a void*. */
868 result = cp_convert (type, result);
869 return ifnonnull (expr, result);
873 errstr = "source type is not polymorphic";
876 cp_error ("cannot dynamic_cast `%E' (of type `%#T') to type `%#T' (%s)",
877 expr, exprtype, type, errstr);
878 return error_mark_node;
882 build_dynamic_cast (type, expr)
885 if (type == error_mark_node || expr == error_mark_node)
886 return error_mark_node;
888 if (processing_template_decl)
889 return build_min (DYNAMIC_CAST_EXPR, type, expr);
891 return convert_from_reference (build_dynamic_cast_1 (type, expr));
894 /* Build and initialize various sorts of descriptors. Every descriptor
895 node has a name associated with it (the name created by mangling).
896 For this reason, we use the identifier as our access to the __*_desc
897 nodes, instead of sticking them directly in the types. Otherwise we
898 would burden all built-in types (and pointer types) with slots that
899 we don't necessarily want to use.
901 For each descriptor we build, we build a variable that contains
902 the descriptor's information. When we need this info at runtime,
903 all we need is access to these variables.
905 Note: these constructors always return the address of the descriptor
906 info, since that is simplest for their mutual interaction. */
908 /* Build an initializer for a __si_type_info node. */
911 expand_si_desc (tdecl, type)
916 tree name_string = tinfo_name (type);
918 type = BINFO_TYPE (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), 0));
919 finish_expr_stmt (get_typeid_1 (type));
920 t = decay_conversion (get_tinfo_var (type));
922 (NULL_TREE, decay_conversion (tdecl), tree_cons
923 (NULL_TREE, decay_conversion (name_string), tree_cons
924 (NULL_TREE, t, NULL_TREE)));
926 fn = get_identifier ("__rtti_si");
927 if (IDENTIFIER_GLOBAL_VALUE (fn))
928 fn = IDENTIFIER_GLOBAL_VALUE (fn);
933 (NULL_TREE, ptr_type_node, tree_cons
934 (NULL_TREE, const_string_type_node, tree_cons
935 (NULL_TREE, build_pointer_type (type_info_type_node),
937 fn = push_void_library_fn (fn, tmp);
940 fn = build_call (fn, elems);
941 finish_expr_stmt (fn);
944 /* Build an initializer for a __class_type_info node. */
947 expand_class_desc (tdecl, type)
954 int i = CLASSTYPE_N_BASECLASSES (type);
956 tree binfos = TYPE_BINFO_BASETYPES (type);
957 tree base, elems, access, offset, isvir;
958 tree elt, elts = NULL_TREE;
960 if (base_desc_type_node == NULL_TREE)
964 /* A reasonably close approximation of __class_type_info::base_info */
966 base_desc_type_node = make_aggr_type (RECORD_TYPE);
968 /* Actually const __user_type_info * */
969 fields [0] = build_decl
970 (FIELD_DECL, NULL_TREE,
971 build_pointer_type (build_qualified_type
972 (type_info_type_node,
974 fields [1] = build_decl
975 (FIELD_DECL, NULL_TREE,
976 flag_new_abi ? intSI_type_node : unsigned_intSI_type_node);
977 DECL_BIT_FIELD (fields[1]) = 1;
978 DECL_SIZE (fields[1]) = bitsize_int (29);
980 fields [2] = build_decl (FIELD_DECL, NULL_TREE, boolean_type_node);
981 DECL_BIT_FIELD (fields[2]) = 1;
982 DECL_SIZE (fields[2]) = bitsize_one_node;
984 /* Actually enum access */
985 fields [3] = build_decl (FIELD_DECL, NULL_TREE, integer_type_node);
986 DECL_BIT_FIELD (fields[3]) = 1;
987 DECL_SIZE (fields[3]) = bitsize_int (2);
989 finish_builtin_type (base_desc_type_node, "__base_info", fields,
995 tree binfo = TREE_VEC_ELT (binfos, i);
997 finish_expr_stmt (get_typeid_1 (BINFO_TYPE (binfo)));
998 base = decay_conversion (get_tinfo_var (BINFO_TYPE (binfo)));
999 offset = get_base_offset (binfo, type);
1001 if (TREE_VIA_PUBLIC (binfo))
1002 access = access_public_node;
1003 else if (TREE_VIA_PROTECTED (binfo))
1004 access = access_protected_node;
1006 access = access_private_node;
1007 if (TREE_VIA_VIRTUAL (binfo))
1008 isvir = boolean_true_node;
1010 isvir = boolean_false_node;
1013 (CONSTRUCTOR, base_desc_type_node, NULL_TREE, tree_cons
1014 (NULL_TREE, base, tree_cons
1015 (NULL_TREE, offset, tree_cons
1016 (NULL_TREE, isvir, tree_cons
1017 (NULL_TREE, access, NULL_TREE)))));
1018 TREE_HAS_CONSTRUCTOR (elt) = TREE_CONSTANT (elt) = TREE_STATIC (elt) = 1;
1019 elts = tree_cons (NULL_TREE, elt, elts);
1023 name_string = tinfo_name (type);
1026 tree arrtype = build_array_type (base_desc_type_node, NULL_TREE);
1027 elts = build (CONSTRUCTOR, arrtype, NULL_TREE, elts);
1028 TREE_HAS_CONSTRUCTOR (elts) = TREE_CONSTANT (elts)
1029 = TREE_STATIC (elts) = 1;
1030 complete_array_type (arrtype, elts, 1);
1034 (NULL_TREE, decay_conversion (tdecl), tree_cons
1035 (NULL_TREE, decay_conversion (name_string), tree_cons
1036 (NULL_TREE, decay_conversion (elts), tree_cons
1037 (NULL_TREE, cp_convert (sizetype, build_int_2 (base_cnt, 0)),
1040 fn = get_identifier ("__rtti_class");
1041 if (IDENTIFIER_GLOBAL_VALUE (fn))
1042 fn = IDENTIFIER_GLOBAL_VALUE (fn);
1046 (NULL_TREE, ptr_type_node, tree_cons
1047 (NULL_TREE, const_string_type_node, tree_cons
1048 (NULL_TREE, build_pointer_type (base_desc_type_node), tree_cons
1049 (NULL_TREE, sizetype, void_list_node))));
1051 fn = push_void_library_fn (fn, tmp);
1054 fn = build_call (fn, elems);
1055 finish_expr_stmt (fn);
1058 /* Build an initializer for a __pointer_type_info node. */
1061 expand_ptr_desc (tdecl, type)
1066 tree name_string = tinfo_name (type);
1068 type = TREE_TYPE (type);
1069 finish_expr_stmt (get_typeid_1 (type));
1070 t = decay_conversion (get_tinfo_var (type));
1072 (NULL_TREE, decay_conversion (tdecl), tree_cons
1073 (NULL_TREE, decay_conversion (name_string), tree_cons
1074 (NULL_TREE, t, NULL_TREE)));
1076 fn = get_identifier ("__rtti_ptr");
1077 if (IDENTIFIER_GLOBAL_VALUE (fn))
1078 fn = IDENTIFIER_GLOBAL_VALUE (fn);
1083 (NULL_TREE, ptr_type_node, tree_cons
1084 (NULL_TREE, const_string_type_node, tree_cons
1085 (NULL_TREE, build_pointer_type (type_info_type_node),
1087 fn = push_void_library_fn (fn, tmp);
1090 fn = build_call (fn, elems);
1091 finish_expr_stmt (fn);
1094 /* Build an initializer for a __attr_type_info node. */
1097 expand_attr_desc (tdecl, type)
1102 tree name_string = tinfo_name (type);
1103 tree attrval = build_int_2 (TYPE_QUALS (type), 0);
1105 finish_expr_stmt (get_typeid_1 (TYPE_MAIN_VARIANT (type)));
1106 t = decay_conversion (get_tinfo_var (TYPE_MAIN_VARIANT (type)));
1108 (NULL_TREE, decay_conversion (tdecl), tree_cons
1109 (NULL_TREE, decay_conversion (name_string), tree_cons
1110 (NULL_TREE, attrval, tree_cons (NULL_TREE, t, NULL_TREE))));
1112 fn = get_identifier ("__rtti_attr");
1113 if (IDENTIFIER_GLOBAL_VALUE (fn))
1114 fn = IDENTIFIER_GLOBAL_VALUE (fn);
1119 (NULL_TREE, ptr_type_node, tree_cons
1120 (NULL_TREE, const_string_type_node, tree_cons
1121 (NULL_TREE, integer_type_node, tree_cons
1122 (NULL_TREE, build_pointer_type (type_info_type_node),
1124 fn = push_void_library_fn (fn, tmp);
1127 fn = build_call (fn, elems);
1128 finish_expr_stmt (fn);
1131 /* Build an initializer for a type_info node that just has a name. */
1134 expand_generic_desc (tdecl, type, fnname)
1139 tree name_string = tinfo_name (type);
1140 tree elems = tree_cons
1141 (NULL_TREE, decay_conversion (tdecl), tree_cons
1142 (NULL_TREE, decay_conversion (name_string), NULL_TREE));
1144 tree fn = get_identifier (fnname);
1145 if (IDENTIFIER_GLOBAL_VALUE (fn))
1146 fn = IDENTIFIER_GLOBAL_VALUE (fn);
1151 (NULL_TREE, ptr_type_node, tree_cons
1152 (NULL_TREE, const_string_type_node, void_list_node));
1153 fn = push_void_library_fn (fn, tmp);
1156 fn = build_call (fn, elems);
1157 finish_expr_stmt (fn);
1160 /* Generate the code for a type_info initialization function.
1161 Note that we take advantage of the passage
1163 5.2.7 Type identification [expr.typeid]
1165 Whether or not the destructor is called for the type_info object at the
1166 end of the program is unspecified.
1168 and don't bother to arrange for these objects to be destroyed. It
1169 doesn't matter, anyway, since the destructors don't do anything.
1171 This must only be called from toplevel (i.e. from finish_file)! */
1174 synthesize_tinfo_fn (fndecl)
1177 tree type = TREE_TYPE (DECL_NAME (fndecl));
1178 tree tmp, addr, tdecl;
1183 my_friendly_assert (!new_abi_rtti_p (), 20000118);
1186 import_export_decl (fndecl);
1187 if (DECL_REALLY_EXTERN (fndecl))
1191 /* Declare the static typeinfo variable. */
1192 tdecl = get_tinfo_var (type);
1193 DECL_EXTERNAL (tdecl) = 0;
1194 TREE_STATIC (tdecl) = 1;
1195 DECL_COMMON (tdecl) = 1;
1196 TREE_USED (tdecl) = 1;
1197 DECL_ALIGN (tdecl) = TYPE_ALIGN (ptr_type_node);
1198 DECL_USER_ALIGN (tdecl) = 0;
1199 cp_finish_decl (tdecl, NULL_TREE, NULL_TREE, 0);
1201 /* Begin processing the function. */
1202 start_function (NULL_TREE, fndecl, NULL_TREE,
1203 SF_DEFAULT | SF_PRE_PARSED);
1204 DECL_DEFER_OUTPUT (fndecl) = 1;
1205 store_parm_decls ();
1208 /* Begin the body of the function. */
1209 compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
1211 /* For convenience, we save away the address of the static
1213 addr = decay_conversion (tdecl);
1215 /* If the first word of the array (the vtable) is non-zero, we've already
1216 initialized the object, so don't do it again. */
1217 if_stmt = begin_if_stmt ();
1218 tmp = cp_convert (build_pointer_type (ptr_type_node), addr);
1219 tmp = build_indirect_ref (tmp, 0);
1220 tmp = cp_build_binary_op (EQ_EXPR, tmp, integer_zero_node);
1221 finish_if_stmt_cond (tmp, if_stmt);
1222 then_clause = begin_compound_stmt (/*has_no_scope=*/0);
1224 if (TREE_CODE (type) == FUNCTION_TYPE)
1225 expand_generic_desc (tdecl, type, "__rtti_func");
1226 else if (TREE_CODE (type) == ARRAY_TYPE)
1227 expand_generic_desc (tdecl, type, "__rtti_array");
1228 else if (TYPE_QUALS (type) != TYPE_UNQUALIFIED)
1229 expand_attr_desc (tdecl, type);
1230 else if (TREE_CODE (type) == POINTER_TYPE)
1232 if (TREE_CODE (TREE_TYPE (type)) == OFFSET_TYPE)
1233 expand_generic_desc (tdecl, type, "__rtti_ptmd");
1234 else if (TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)
1235 expand_generic_desc (tdecl, type, "__rtti_ptmf");
1237 expand_ptr_desc (tdecl, type);
1239 else if (TYPE_PTRMEMFUNC_P (type))
1240 expand_generic_desc (tdecl, type, "__rtti_ptmf");
1241 else if (IS_AGGR_TYPE (type))
1243 if (CLASSTYPE_N_BASECLASSES (type) == 0)
1244 expand_generic_desc (tdecl, type, "__rtti_user");
1245 else if (! TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type)
1247 (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), 0))))
1248 expand_si_desc (tdecl, type);
1250 expand_class_desc (tdecl, type);
1252 else if (TREE_CODE (type) == ENUMERAL_TYPE)
1253 expand_generic_desc (tdecl, type, "__rtti_user");
1255 my_friendly_abort (252);
1257 finish_compound_stmt (/*has_no_scope=*/0, then_clause);
1258 finish_then_clause (if_stmt);
1261 /* OK, now return the type_info object. */
1262 tmp = cp_convert (build_pointer_type (type_info_type_node), addr);
1263 tmp = build_indirect_ref (tmp, 0);
1264 finish_return_stmt (tmp);
1265 /* Finish the function body. */
1266 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
1267 expand_body (finish_function (0));
1270 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
1273 qualifier_flags (type)
1277 /* we want the qualifiers on this type, not any array core, it might have */
1278 int quals = TYPE_QUALS (type);
1280 if (quals & TYPE_QUAL_CONST)
1282 if (quals & TYPE_QUAL_VOLATILE)
1284 if (quals & TYPE_QUAL_RESTRICT)
1289 /* Return non-zero, if the pointer chain TYPE ends at an incomplete type, or
1290 contains a pointer to member of an incomplete class. */
1293 target_incomplete_p (type)
1296 while (TREE_CODE (type) == POINTER_TYPE)
1297 if (TYPE_PTRMEM_P (type))
1299 if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type)))
1301 type = TYPE_PTRMEM_POINTED_TO_TYPE (type);
1304 type = TREE_TYPE (type);
1305 if (!COMPLETE_OR_VOID_TYPE_P (type))
1311 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
1312 is the vtable pointer and NTBS name. The NTBS name is emitted as a
1313 comdat const char array, so it becomes a unique key for the type. Generate
1314 and emit that VAR_DECL here. (We can't always emit the type_info itself
1315 as comdat, because of pointers to incomplete.) */
1318 tinfo_base_init (desc, target)
1322 tree init = NULL_TREE;
1328 /* Generate the NTBS array variable. */
1329 tree name_type = build_cplus_array_type
1330 (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
1332 tree name_string = tinfo_name (target);
1335 name_name = mangle_typeinfo_for_type (target);
1337 name_name = build_overload_with_type (tinfo_var_id, target);
1338 name_decl = build_lang_decl (VAR_DECL, name_name, name_type);
1340 DECL_ARTIFICIAL (name_decl) = 1;
1341 TREE_READONLY (name_decl) = 1;
1342 TREE_STATIC (name_decl) = 1;
1343 DECL_EXTERNAL (name_decl) = 0;
1344 TREE_PUBLIC (name_decl) = 1;
1345 comdat_linkage (name_decl);
1347 /* The new ABI specifies the external name of the string
1348 containing the type's name. */
1349 DECL_ASSEMBLER_NAME (name_decl)
1350 = mangle_typeinfo_string_for_type (target);
1352 DECL_ASSEMBLER_NAME (name_decl) = DECL_NAME (name_decl);
1353 DECL_INITIAL (name_decl) = name_string;
1354 cp_finish_decl (name_decl, name_string, NULL_TREE, 0);
1357 if (TINFO_VTABLE_DECL (desc))
1359 tree vtbl_ptr = TINFO_VTABLE_DECL (desc);
1360 init = tree_cons (NULL_TREE, vtbl_ptr, init);
1363 init = tree_cons (NULL_TREE, decay_conversion (name_decl), init);
1365 init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, nreverse (init));
1366 TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
1367 init = tree_cons (NULL_TREE, init, NULL_TREE);
1372 /* Return the CONSTRUCTOR expr for a type_info of TYPE. DESC provides the
1373 information about the particular type_info derivation, which adds no
1374 additional fields to the type_info base. */
1377 generic_initializer (desc, target)
1381 tree init = tinfo_base_init (desc, target);
1383 init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, init);
1384 TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
1388 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
1389 DESC provides information about the particular type_info derivation,
1390 which adds target type and qualifier flags members to the type_info base. */
1393 ptr_initializer (desc, target, non_public_ptr)
1396 int *non_public_ptr;
1398 tree init = tinfo_base_init (desc, target);
1399 tree to = TREE_TYPE (target);
1400 int flags = qualifier_flags (to);
1401 int incomplete = target_incomplete_p (to);
1406 *non_public_ptr = 1;
1408 init = tree_cons (NULL_TREE, build_int_2 (flags, 0), init);
1409 init = tree_cons (NULL_TREE,
1410 build_unary_op (ADDR_EXPR,
1411 get_tinfo_decl (TYPE_MAIN_VARIANT (to)), 0),
1414 init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, nreverse (init));
1415 TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
1419 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
1420 DESC provides information about the particular type_info derivation,
1421 which adds class, target type and qualifier flags members to the type_info
1425 ptm_initializer (desc, target, non_public_ptr)
1428 int *non_public_ptr;
1430 tree init = tinfo_base_init (desc, target);
1431 tree to = TYPE_PTRMEM_POINTED_TO_TYPE (target);
1432 tree klass = TYPE_PTRMEM_CLASS_TYPE (target);
1433 int flags = qualifier_flags (to);
1434 int incomplete = target_incomplete_p (to);
1439 *non_public_ptr = 1;
1441 if (!COMPLETE_TYPE_P (klass))
1444 *non_public_ptr = 1;
1446 init = tree_cons (NULL_TREE, build_int_2 (flags, 0), init);
1447 init = tree_cons (NULL_TREE,
1448 build_unary_op (ADDR_EXPR,
1449 get_tinfo_decl (TYPE_MAIN_VARIANT (to)), 0),
1451 init = tree_cons (NULL_TREE,
1452 build_unary_op (ADDR_EXPR, get_tinfo_decl (klass), 0),
1455 init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, nreverse (init));
1456 TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
1460 /* Check base BINFO to set hint flags in *DATA, which is really an int.
1461 We use CLASSTYPE_MARKED to tag types we've found as non-virtual bases and
1462 CLASSTYPE_MARKED2 to tag those which are virtual bases. Remember it is
1463 possible for a type to be both a virtual and non-virtual base. */
1466 dfs_class_hint_mark (binfo, data)
1470 tree basetype = BINFO_TYPE (binfo);
1471 int *hint = (int *) data;
1473 if (TREE_VIA_VIRTUAL (binfo))
1475 if (CLASSTYPE_MARKED (basetype))
1477 if (CLASSTYPE_MARKED2 (basetype))
1479 SET_CLASSTYPE_MARKED2 (basetype);
1483 if (CLASSTYPE_MARKED (basetype) || CLASSTYPE_MARKED2 (basetype))
1485 SET_CLASSTYPE_MARKED (basetype);
1487 if (!TREE_VIA_PUBLIC (binfo) && TYPE_BINFO (basetype) != binfo)
1492 /* Clear the base's dfs marks, after searching for duplicate bases. */
1495 dfs_class_hint_unmark (binfo, data)
1497 void *data ATTRIBUTE_UNUSED;
1499 tree basetype = BINFO_TYPE (binfo);
1501 CLEAR_CLASSTYPE_MARKED (basetype);
1502 CLEAR_CLASSTYPE_MARKED2 (basetype);
1506 /* Determine the hint flags describing the features of a class's heirarchy. */
1509 class_hint_flags (type)
1515 dfs_walk (TYPE_BINFO (type), dfs_class_hint_mark, NULL, &hint_flags);
1516 dfs_walk (TYPE_BINFO (type), dfs_class_hint_unmark, NULL, NULL);
1518 for (i = 0; i < CLASSTYPE_N_BASECLASSES (type); ++i)
1520 tree base_binfo = BINFO_BASETYPE (TYPE_BINFO (type), i);
1522 if (TREE_VIA_PUBLIC (base_binfo))
1528 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
1529 DESC provides information about the particular __class_type_info derivation,
1530 which adds hint flags and TRAIL initializers to the type_info base. */
1533 class_initializer (desc, target, trail)
1538 tree init = tinfo_base_init (desc, target);
1540 TREE_CHAIN (init) = trail;
1541 init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, init);
1542 TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
1546 /* Generate a pseudo_type_info VAR_DECL suitable for the supplied
1547 TARGET_TYPE and given the REAL_NAME. This is the structure expected by
1548 the runtime, and therefore has additional fields. If we need not emit a
1549 definition (because the runtime must contain it), return NULL_TREE,
1550 otherwise return the VAR_DECL. */
1553 synthesize_tinfo_var (target_type, real_name)
1557 tree var_init = NULL_TREE;
1558 tree var_type = NULL_TREE;
1561 my_friendly_assert (new_abi_rtti_p (), 20000118);
1563 switch (TREE_CODE (target_type))
1566 if (TYPE_PTRMEM_P (target_type))
1568 var_type = ptm_desc_type_node;
1569 var_init = ptm_initializer (var_type, target_type, &non_public);
1573 int code = TREE_CODE (TREE_TYPE (target_type));
1575 if ((CP_TYPE_QUALS (TREE_TYPE (target_type)) | TYPE_QUAL_CONST)
1577 && (code == INTEGER_TYPE || code == BOOLEAN_TYPE
1578 || code == CHAR_TYPE || code == REAL_TYPE
1579 || code == VOID_TYPE)
1581 /* These are in the runtime. */
1583 var_type = ptr_desc_type_node;
1584 var_init = ptr_initializer (var_type, target_type, &non_public);
1588 var_type = enum_desc_type_node;
1589 var_init = generic_initializer (var_type, target_type);
1592 var_type = func_desc_type_node;
1593 var_init = generic_initializer (var_type, target_type);
1596 var_type = ary_desc_type_node;
1597 var_init = generic_initializer (var_type, target_type);
1601 if (TYPE_PTRMEMFUNC_P (target_type))
1603 var_type = ptm_desc_type_node;
1604 var_init = ptm_initializer (var_type, target_type, &non_public);
1606 else if (!COMPLETE_TYPE_P (target_type))
1608 /* Emit a non-public class_type_info. */
1610 var_type = class_desc_type_node;
1611 var_init = class_initializer (var_type, target_type, NULL_TREE);
1613 else if (!CLASSTYPE_N_BASECLASSES (target_type))
1615 var_type = class_desc_type_node;
1616 var_init = class_initializer (var_type, target_type, NULL_TREE);
1620 /* if this has a single public non-virtual base, it's easier */
1621 tree binfo = TYPE_BINFO (target_type);
1622 int nbases = BINFO_N_BASETYPES (binfo);
1623 tree base_binfos = BINFO_BASETYPES (binfo);
1624 tree base_inits = NULL_TREE;
1625 int is_simple = nbases == 1;
1628 /* Generate the base information initializer. */
1629 for (ix = nbases; ix--;)
1631 tree base_binfo = TREE_VEC_ELT (base_binfos, ix);
1632 tree base_init = NULL_TREE;
1637 if (TREE_VIA_VIRTUAL (base_binfo))
1639 if (TREE_PUBLIC (base_binfo))
1641 tinfo = get_tinfo_decl (BINFO_TYPE (base_binfo));
1642 tinfo = build_unary_op (ADDR_EXPR, tinfo, 0);
1643 offset = get_base_offset (base_binfo, target_type);
1645 /* is it a single public inheritance? */
1646 if (is_simple && flags == 2 && integer_zerop (offset))
1648 base_inits = tree_cons (NULL_TREE, tinfo, NULL_TREE);
1653 /* combine offset and flags into one field */
1654 offset = cp_build_binary_op (LSHIFT_EXPR, offset,
1655 build_int_2 (8, 0));
1656 offset = cp_build_binary_op (BIT_IOR_EXPR, offset,
1657 build_int_2 (flags, 0));
1658 base_init = tree_cons (NULL_TREE, offset, base_init);
1659 base_init = tree_cons (NULL_TREE, tinfo, base_init);
1660 base_init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, base_init);
1661 base_inits = tree_cons (NULL_TREE, base_init, base_inits);
1665 var_type = si_class_desc_type_node;
1668 int hint = class_hint_flags (target_type);
1670 base_inits = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, base_inits);
1671 base_inits = tree_cons (NULL_TREE, base_inits, NULL_TREE);
1672 /* Prepend the number of bases. */
1673 base_inits = tree_cons (NULL_TREE,
1674 build_int_2 (nbases, 0), base_inits);
1675 /* Prepend the hint flags. */
1676 base_inits = tree_cons (NULL_TREE,
1677 build_int_2 (hint, 0), base_inits);
1678 var_type = get_vmi_pseudo_type_info (nbases);
1680 var_init = class_initializer (var_type, target_type, base_inits);
1689 /* These are guaranteed to be in the runtime. */
1691 var_type = bltn_desc_type_node;
1692 var_init = generic_initializer (var_type, target_type);
1695 my_friendly_abort (20000117);
1699 return create_real_tinfo_var (real_name, TINFO_PSEUDO_TYPE (var_type),
1700 var_init, non_public);
1703 /* Create the real typeinfo variable. NON_PUBLIC indicates that we cannot
1704 make this variable public (comdat). */
1707 create_real_tinfo_var (name, type, init, non_public)
1713 static int count = 0;
1718 sprintf (hidden, "%.*s_%d",
1719 IDENTIFIER_LENGTH (tinfo_decl_id), IDENTIFIER_POINTER (tinfo_decl_id),
1721 hidden_name = get_identifier (hidden);
1723 decl = build_lang_decl (VAR_DECL, hidden_name,
1724 build_qualified_type (type, TYPE_QUAL_CONST));
1725 DECL_ARTIFICIAL (decl) = 1;
1726 TREE_READONLY (decl) = 1;
1727 TREE_STATIC (decl) = 1;
1728 DECL_EXTERNAL (decl) = 0;
1732 TREE_PUBLIC (decl) = 1;
1733 comdat_linkage (decl);
1735 DECL_ASSEMBLER_NAME (decl) = name;
1736 DECL_INITIAL (decl) = init;
1737 cp_finish_decl (decl, init, NULL_TREE, 0);
1738 pushdecl_top_level (decl);
1739 TREE_USED (decl) = 1;
1743 /* Generate the RECORD_TYPE containing the data layout of a type_info
1744 derivative as used by the runtime. This layout must be consistent with
1745 that defined in the runtime support. Also generate the VAR_DECL for the
1746 type's vtable. We explicitly manage the vtable member, and name it for
1747 real type as used in the runtime. The RECORD type has a different name,
1748 to avoid collisions. Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1749 is the generated type and TINFO_VTABLE_DECL is the vtable decl.
1751 REAL_NAME is the runtime's name of the type. Trailing arguments are
1752 additional FIELD_DECL's for the structure. The final argument must be
1756 create_pseudo_type_info VPARAMS((const char *real_name, int ident, ...))
1758 #ifndef ANSI_PROTOTYPES
1759 char const *real_name;
1763 tree real_type, pseudo_type;
1771 VA_START (ap, ident);
1772 #ifndef ANSI_PROTOTYPES
1773 real_name = va_arg (ap, char const *);
1774 ident = va_arg (app, int);
1777 /* Generate the pseudo type name. */
1778 pseudo_name = (char *)alloca (strlen (real_name) + 30);
1779 strcpy (pseudo_name, real_name);
1780 strcat (pseudo_name, "_pseudo");
1782 sprintf (pseudo_name + strlen (pseudo_name), "%d", ident);
1784 /* Get the vtable decl. */
1785 real_type = xref_tag (class_type_node, get_identifier (real_name), 1);
1786 vtable_decl = get_vtable_decl (real_type, /*complete=*/1);
1787 vtable_decl = build_unary_op (ADDR_EXPR, vtable_decl, 0);
1789 /* Under the new ABI, we need to point into the middle of the
1793 vtable_decl = build (PLUS_EXPR,
1794 TREE_TYPE (vtable_decl),
1796 size_binop (MULT_EXPR,
1798 TYPE_SIZE_UNIT (vtable_entry_type)));
1799 TREE_CONSTANT (vtable_decl) = 1;
1802 /* First field is the pseudo type_info base class. */
1803 fields[0] = build_decl (FIELD_DECL, NULL_TREE, ti_desc_type_node);
1805 /* Now add the derived fields. */
1806 for (ix = 0; (field_decl = va_arg (ap, tree));)
1807 fields[++ix] = field_decl;
1809 /* Create the pseudo type. */
1810 pseudo_type = make_aggr_type (RECORD_TYPE);
1811 finish_builtin_type (pseudo_type, pseudo_name, fields, ix, ptr_type_node);
1812 TYPE_HAS_CONSTRUCTOR (pseudo_type) = 1;
1815 result = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE);
1816 TINFO_VTABLE_DECL (result) = vtable_decl;
1817 TINFO_PSEUDO_TYPE (result) = pseudo_type;
1822 /* Return a descriptor for a vmi type with NUM_BASES bases. */
1825 get_vmi_pseudo_type_info (num_bases)
1829 tree array_domain, base_array;
1831 if (TREE_VEC_LENGTH (vmi_class_desc_type_node) <= num_bases)
1834 tree extend = make_tree_vec (num_bases + 5);
1836 for (ix = TREE_VEC_LENGTH (vmi_class_desc_type_node); ix--;)
1837 TREE_VEC_ELT (extend, ix) = TREE_VEC_ELT (vmi_class_desc_type_node, ix);
1838 vmi_class_desc_type_node = extend;
1840 desc = TREE_VEC_ELT (vmi_class_desc_type_node, num_bases);
1845 /* Add number of bases and trailing array of base_class_type_info. */
1846 array_domain = build_index_type (build_int_2 (num_bases, 0));
1847 base_array = build_array_type (base_desc_type_node, array_domain);
1849 push_nested_namespace (abi_node);
1851 desc = create_pseudo_type_info
1852 ("__vmi_class_type_info", num_bases,
1853 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1854 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1855 build_decl (FIELD_DECL, NULL_TREE, base_array),
1858 pop_nested_namespace (abi_node);
1860 TREE_VEC_ELT (vmi_class_desc_type_node, num_bases) = desc;
1864 /* Make sure the required builtin types exist for generating the type_info
1865 varable definitions. */
1868 create_tinfo_types ()
1872 if (bltn_desc_type_node)
1874 push_nested_namespace (abi_node);
1876 ptr_type_info = build_pointer_type
1877 (build_qualified_type
1878 (type_info_type_node, TYPE_QUAL_CONST));
1880 /* Create the internal type_info structure. This is used as a base for
1881 the other structures. */
1885 ti_desc_type_node = make_aggr_type (RECORD_TYPE);
1886 fields[0] = build_decl (FIELD_DECL, NULL_TREE, const_ptr_type_node);
1887 fields[1] = build_decl (FIELD_DECL, NULL_TREE, const_string_type_node);
1888 finish_builtin_type (ti_desc_type_node, "__type_info_pseudo",
1889 fields, 1, ptr_type_node);
1890 TYPE_HAS_CONSTRUCTOR (ti_desc_type_node) = 1;
1893 /* Fundamental type_info */
1894 bltn_desc_type_node = create_pseudo_type_info
1895 ("__fundamental_type_info", 0,
1898 /* Array, function and enum type_info. No additional fields. */
1899 ary_desc_type_node = create_pseudo_type_info
1900 ("__array_type_info", 0,
1902 func_desc_type_node = create_pseudo_type_info
1903 ("__function_type_info", 0,
1905 enum_desc_type_node = create_pseudo_type_info
1906 ("__enum_type_info", 0,
1909 /* Class type_info. Add a flags field. */
1910 class_desc_type_node = create_pseudo_type_info
1911 ("__class_type_info", 0,
1914 /* Single public non-virtual base class. Add pointer to base class.
1915 This is really a descendant of __class_type_info. */
1916 si_class_desc_type_node = create_pseudo_type_info
1917 ("__si_class_type_info", 0,
1918 build_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
1921 /* Base class internal helper. Pointer to base type, offset to base,
1926 fields[0] = build_decl (FIELD_DECL, NULL_TREE, ptr_type_info);
1927 fields[1] = build_decl (FIELD_DECL, NULL_TREE, integer_types[itk_long]);
1928 base_desc_type_node = make_aggr_type (RECORD_TYPE);
1929 finish_builtin_type (base_desc_type_node, "__base_class_type_info_pseudo",
1930 fields, 1, ptr_type_node);
1931 TYPE_HAS_CONSTRUCTOR (base_desc_type_node) = 1;
1934 /* General heirarchy is created as necessary in this vector. */
1935 vmi_class_desc_type_node = make_tree_vec (10);
1937 /* Pointer type_info. Adds two fields, qualification mask
1938 and pointer to the pointed to type. This is really a descendant of
1939 __pbase_type_info. */
1940 ptr_desc_type_node = create_pseudo_type_info
1941 ("__pointer_type_info", 0,
1942 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1943 build_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
1946 /* Pointer to member data type_info. Add qualifications flags,
1947 pointer to the member's type info and pointer to the class.
1948 This is really a descendant of __pbase_type_info. */
1949 ptm_desc_type_node = create_pseudo_type_info
1950 ("__pointer_to_member_type_info", 0,
1951 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1952 build_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
1953 build_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
1956 pop_nested_namespace (abi_node);
1959 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1960 support. Generating them here guarantees consistency with the other
1961 structures. We use the following heuristic to determine when the runtime
1962 is being generated. If std::__fundamental_type_info is defined, and it's
1963 destructor is defined, then the runtime is being built. */
1966 emit_support_tinfos ()
1968 static tree *const fundamentals[] =
1973 &char_type_node, &signed_char_type_node, &unsigned_char_type_node,
1974 &short_integer_type_node, &short_unsigned_type_node,
1975 &integer_type_node, &unsigned_type_node,
1976 &long_integer_type_node, &long_unsigned_type_node,
1977 &long_long_integer_type_node, &long_long_unsigned_type_node,
1978 &float_type_node, &double_type_node, &long_double_type_node,
1982 tree bltn_type, dtor;
1984 push_nested_namespace (abi_node);
1985 bltn_type = xref_tag (class_type_node,
1986 get_identifier ("__fundamental_type_info"), 1);
1987 pop_nested_namespace (abi_node);
1988 if (!COMPLETE_TYPE_P (bltn_type))
1990 dtor = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (bltn_type), 1);
1991 if (DECL_EXTERNAL (dtor))
1994 for (ix = 0; fundamentals[ix]; ix++)
1996 tree bltn = *fundamentals[ix];
1997 tree bltn_ptr = build_pointer_type (bltn);
1998 tree bltn_const_ptr = build_pointer_type
1999 (build_qualified_type (bltn, TYPE_QUAL_CONST));
2002 tinfo = get_tinfo_decl (bltn);
2003 TREE_USED (tinfo) = 1;
2004 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo)) = 1;
2006 tinfo = get_tinfo_decl (bltn_ptr);
2007 TREE_USED (tinfo) = 1;
2008 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo)) = 1;
2010 tinfo = get_tinfo_decl (bltn_const_ptr);
2011 TREE_USED (tinfo) = 1;
2012 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo)) = 1;
2016 /* Return non-zero, iff T is a type_info variable which has not had a
2017 definition emitted for it. */
2020 tinfo_decl_p (t, data)
2022 void *data ATTRIBUTE_UNUSED;
2024 return TREE_CODE (t) == VAR_DECL
2025 && IDENTIFIER_GLOBAL_VALUE (DECL_NAME (t)) == (t)
2026 && TREE_TYPE (t) == tinfo_decl_type
2027 && TREE_TYPE (DECL_NAME (t));
2030 /* Emit a suitable type_info definition for the type_info decl pointed to by
2031 DECL_PTR. We emit a completely new variable, of the correct type for the
2032 actual type this is describing. The DECL_ASSEMBLER_NAME of the generated
2033 definition is set to that of the supplied decl, so that they can be tied
2034 up. Mark the supplied decl as having been dealt with. Emitting one
2035 definition might cause other definitions to be required.
2037 We need to do things this way, because we're trying to do something like
2043 extern const A tinfo_var;
2045 const B tinfo_var = {...};
2047 which is not permitted. Also, we've not necessarily seen the definition of B.
2048 So we do something like the following,
2050 extern const A tinfo_var;
2053 const void *vtable_ptr;
2061 const pseudo_B proxy_tinfo_var attribute((assembler_name="tinfo_var")) =
2063 {&B::vtable, "..."},
2067 pseudo_A and pseudo_B must be layout equivalent to the real definitions in
2071 emit_tinfo_decl (decl_ptr, data)
2073 void *data ATTRIBUTE_UNUSED;
2075 tree tinfo_decl = *decl_ptr;
2076 tree tinfo_type, decl;
2078 my_friendly_assert (TREE_TYPE (tinfo_decl) == tinfo_decl_type, 20000121);
2079 tinfo_type = TREE_TYPE (DECL_NAME (tinfo_decl));
2080 my_friendly_assert (tinfo_type != NULL_TREE, 20000120);
2082 if (!DECL_NEEDED_P (tinfo_decl))
2084 /* Say we've dealt with it. */
2085 TREE_TYPE (DECL_NAME (tinfo_decl)) = NULL_TREE;
2087 create_tinfo_types ();
2088 decl = synthesize_tinfo_var (tinfo_type, DECL_ASSEMBLER_NAME (tinfo_decl));