1 /* RunTime Type Identification
2 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001
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. */
33 /* Accessors for the type_info objects. We need to remember several things
34 about each of the type_info types. The global tree nodes such as
35 bltn_desc_type_node are TREE_LISTs, and these macros are used to access
36 the required information. */
37 /* The RECORD_TYPE of a type_info derived class. */
38 #define TINFO_PSEUDO_TYPE(NODE) TREE_TYPE (NODE)
39 /* The VAR_DECL of the vtable for the type_info derived class. */
40 #define TINFO_VTABLE_DECL(NODE) TREE_VALUE (NODE)
42 extern struct obstack permanent_obstack;
44 static tree build_headof_sub PARAMS((tree));
45 static tree build_headof PARAMS((tree));
46 static tree ifnonnull PARAMS((tree, tree));
47 static tree tinfo_name PARAMS((tree));
48 static tree build_dynamic_cast_1 PARAMS((tree, tree));
49 static tree throw_bad_cast PARAMS((void));
50 static tree throw_bad_typeid PARAMS((void));
51 static tree get_tinfo_decl_dynamic PARAMS((tree));
52 static bool typeid_ok_p PARAMS ((void));
53 static int qualifier_flags PARAMS((tree));
54 static int target_incomplete_p PARAMS((tree));
55 static tree tinfo_base_init PARAMS((tree, tree));
56 static tree generic_initializer PARAMS((tree, tree));
57 static tree ptr_initializer PARAMS((tree, tree, int *));
58 static tree ptm_initializer PARAMS((tree, tree, int *));
59 static tree dfs_class_hint_mark PARAMS ((tree, void *));
60 static tree dfs_class_hint_unmark PARAMS ((tree, void *));
61 static int class_hint_flags PARAMS((tree));
62 static tree class_initializer PARAMS((tree, tree, tree));
63 static tree synthesize_tinfo_var PARAMS((tree, tree));
64 static tree create_real_tinfo_var PARAMS((tree, tree, tree, tree, int));
65 static tree create_pseudo_type_info PARAMS((const char *, int, ...));
66 static tree get_vmi_pseudo_type_info PARAMS((int));
67 static void create_tinfo_types PARAMS((void));
68 static int typeinfo_in_lib_p PARAMS((tree));
70 static int doing_runtime = 0;
73 init_rtti_processing ()
76 push_namespace (std_identifier);
77 type_info_type_node = xref_tag
78 (class_type_node, get_identifier ("type_info"), 1);
82 build_qualified_type (type_info_type_node, TYPE_QUAL_CONST);
85 /* Given a pointer to an object with at least one virtual table
86 pointer somewhere, return a pointer to a possible sub-object that
87 has a virtual table pointer in it that is the vtable parent for
91 build_headof_sub (exp)
94 tree type = TREE_TYPE (TREE_TYPE (exp));
95 tree basetype = CLASSTYPE_RTTI (type);
96 tree binfo = get_binfo (basetype, type, 0);
98 exp = convert_pointer_to_real (binfo, exp);
102 /* Given the expression EXP of type `class *', return the head of the
103 object pointed to by EXP with type cv void*, if the class has any
104 virtual functions (TYPE_POLYMORPHIC_P), else just return the
111 tree type = TREE_TYPE (exp);
115 my_friendly_assert (TREE_CODE (type) == POINTER_TYPE, 20000112);
116 type = TREE_TYPE (type);
118 if (!TYPE_POLYMORPHIC_P (type))
121 /* If we don't have rtti stuff, get to a sub-object that does. */
122 if (!CLASSTYPE_VFIELDS (TREE_TYPE (TREE_TYPE (exp))))
123 exp = build_headof_sub (exp);
125 /* We use this a couple of times below, protect it. */
126 exp = save_expr (exp);
128 /* The offset-to-top field is at index -2 from the vptr. */
129 index = build_int_2 (-2, -1);
131 offset = build_vtbl_ref (build_indirect_ref (exp, NULL), index);
133 type = build_qualified_type (ptr_type_node,
134 CP_TYPE_QUALS (TREE_TYPE (exp)));
135 return build (PLUS_EXPR, type, exp,
136 cp_convert (ptrdiff_type_node, offset));
139 /* Get a bad_cast node for the program to throw...
141 See libstdc++/exception.cc for __throw_bad_cast */
146 tree fn = get_identifier ("__cxa_bad_cast");
147 if (IDENTIFIER_GLOBAL_VALUE (fn))
148 fn = IDENTIFIER_GLOBAL_VALUE (fn);
150 fn = push_throw_library_fn (fn, build_function_type (ptr_type_node,
153 return build_call (fn, NULL_TREE);
159 tree fn = get_identifier ("__cxa_bad_typeid");
160 if (IDENTIFIER_GLOBAL_VALUE (fn))
161 fn = IDENTIFIER_GLOBAL_VALUE (fn);
164 tree t = build_qualified_type (type_info_type_node, TYPE_QUAL_CONST);
165 t = build_function_type (build_reference_type (t), void_list_node);
166 fn = push_throw_library_fn (fn, t);
169 return build_call (fn, NULL_TREE);
172 /* Return a pointer to type_info function associated with the expression EXP.
173 If EXP is a reference to a polymorphic class, return the dynamic type;
174 otherwise return the static type of the expression. */
177 get_tinfo_decl_dynamic (exp)
182 if (exp == error_mark_node)
183 return error_mark_node;
185 type = TREE_TYPE (exp);
187 /* peel back references, so they match. */
188 if (TREE_CODE (type) == REFERENCE_TYPE)
189 type = TREE_TYPE (type);
191 /* Peel off cv qualifiers. */
192 type = TYPE_MAIN_VARIANT (type);
194 if (!VOID_TYPE_P (type))
195 type = complete_type_or_else (type, exp);
198 return error_mark_node;
200 /* If exp is a reference to polymorphic type, get the real type_info. */
201 if (TYPE_POLYMORPHIC_P (type) && ! resolves_to_fixed_type_p (exp, 0))
203 /* build reference to type_info from vtable. */
208 error ("taking dynamic typeid of object with -fno-rtti");
210 /* If we don't have rtti stuff, get to a sub-object that does. */
211 if (! CLASSTYPE_VFIELDS (type))
213 exp = build_unary_op (ADDR_EXPR, exp, 0);
214 exp = build_headof_sub (exp);
215 exp = build_indirect_ref (exp, NULL);
218 /* The RTTI information is at index -1. */
219 index = integer_minus_one_node;
220 t = build_vfn_ref (exp, index);
221 TREE_TYPE (t) = build_pointer_type (tinfo_decl_type);
225 /* otherwise return the type_info for the static type of the expr. */
226 exp = get_tinfo_decl (TYPE_MAIN_VARIANT (type));
227 return build_unary_op (ADDR_EXPR, exp, 0);
235 error ("cannot use typeid with -fno-rtti");
239 if (!COMPLETE_TYPE_P (type_info_type_node))
241 error ("must #include <typeinfo> before using typeid");
252 tree cond = NULL_TREE;
255 if (exp == error_mark_node || !typeid_ok_p ())
256 return error_mark_node;
258 if (processing_template_decl)
259 return build_min_nt (TYPEID_EXPR, exp);
261 if (TREE_CODE (exp) == INDIRECT_REF
262 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
263 && TYPE_POLYMORPHIC_P (TREE_TYPE (exp))
264 && ! resolves_to_fixed_type_p (exp, &nonnull)
267 exp = stabilize_reference (exp);
268 cond = cp_convert (boolean_type_node, TREE_OPERAND (exp, 0));
271 exp = get_tinfo_decl_dynamic (exp);
273 if (exp == error_mark_node)
274 return error_mark_node;
276 exp = build_indirect_ref (exp, NULL);
280 tree bad = throw_bad_typeid ();
282 exp = build (COND_EXPR, TREE_TYPE (exp), cond, exp, bad);
285 return convert_from_reference (exp);
288 /* Generate the NTBS name of a type. */
296 name = mangle_type_string (type);
297 name_string = combine_strings (build_string (strlen (name) + 1, name));
301 /* Returns a decl for the type_info variable for TYPE. You must
302 arrange that the decl is mark_used, if actually use it --- decls in
303 vtables are only used if the vtable is output. */
306 get_tinfo_decl (type)
312 if (COMPLETE_TYPE_P (type)
313 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
315 cp_error ("cannot create type information for type `%T' because its size is variable",
317 return error_mark_node;
320 if (TREE_CODE (type) == OFFSET_TYPE)
321 type = TREE_TYPE (type);
322 if (TREE_CODE (type) == METHOD_TYPE)
323 type = build_function_type (TREE_TYPE (type),
324 TREE_CHAIN (TYPE_ARG_TYPES (type)));
326 name = mangle_typeinfo_for_type (type);
328 d = IDENTIFIER_GLOBAL_VALUE (name);
333 /* The tinfo decl is the type_info object itself. We make all
334 tinfo objects look as type_info, even though they will end up
335 being a subclass of that when emitted. This means that we'll
336 erroneously think we know the dynamic type -- be careful in the
338 d = build_lang_decl (VAR_DECL, name, tinfo_decl_type);
340 DECL_ARTIFICIAL (d) = 1;
341 DECL_ALIGN (d) = TYPE_ALIGN (ptr_type_node);
342 DECL_USER_ALIGN (d) = 0;
343 TREE_READONLY (d) = 1;
345 DECL_EXTERNAL (d) = 1;
347 if (flag_weak || !typeinfo_in_lib_p (d))
349 SET_DECL_ASSEMBLER_NAME (d, name);
350 cp_finish_decl (d, NULL_TREE, NULL_TREE, 0);
352 pushdecl_top_level (d);
353 /* Remember the type it is for. */
354 TREE_TYPE (name) = type;
355 TREE_USED (name) = 1;
360 /* Return the type_info object for TYPE. */
366 if (type == error_mark_node || !typeid_ok_p ())
367 return error_mark_node;
369 if (processing_template_decl)
370 return build_min_nt (TYPEID_EXPR, type);
372 /* If the type of the type-id is a reference type, the result of the
373 typeid expression refers to a type_info object representing the
375 if (TREE_CODE (type) == REFERENCE_TYPE)
376 type = TREE_TYPE (type);
378 /* The top-level cv-qualifiers of the lvalue expression or the type-id
379 that is the operand of typeid are always ignored. */
380 type = TYPE_MAIN_VARIANT (type);
382 if (!VOID_TYPE_P (type))
383 type = complete_type_or_else (type, NULL_TREE);
386 return error_mark_node;
388 return get_tinfo_decl (type);
391 /* Check whether TEST is null before returning RESULT. If TEST is used in
392 RESULT, it must have previously had a save_expr applied to it. */
395 ifnonnull (test, result)
398 return build (COND_EXPR, TREE_TYPE (result),
399 build (EQ_EXPR, boolean_type_node, test, integer_zero_node),
400 cp_convert (TREE_TYPE (result), integer_zero_node),
404 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
408 build_dynamic_cast_1 (type, expr)
411 enum tree_code tc = TREE_CODE (type);
412 tree exprtype = TREE_TYPE (expr);
414 tree old_expr = expr;
415 const char *errstr = NULL;
417 /* T shall be a pointer or reference to a complete class type, or
418 `pointer to cv void''. */
422 if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
425 if (! IS_AGGR_TYPE (TREE_TYPE (type)))
427 errstr = "target is not pointer or reference to class";
430 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
432 errstr = "target is not pointer or reference to complete type";
438 errstr = "target is not pointer or reference";
442 if (TREE_CODE (expr) == OFFSET_REF)
444 expr = resolve_offset_ref (expr);
445 exprtype = TREE_TYPE (expr);
448 if (tc == POINTER_TYPE)
449 expr = convert_from_reference (expr);
450 else if (TREE_CODE (exprtype) != REFERENCE_TYPE)
452 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
453 exprtype = build_reference_type (exprtype);
454 expr = convert_to_reference (exprtype, expr, CONV_IMPLICIT,
455 LOOKUP_NORMAL, NULL_TREE);
458 exprtype = TREE_TYPE (expr);
460 if (tc == POINTER_TYPE)
462 /* If T is a pointer type, v shall be an rvalue of a pointer to
463 complete class type, and the result is an rvalue of type T. */
465 if (TREE_CODE (exprtype) != POINTER_TYPE)
467 errstr = "source is not a pointer";
470 if (! IS_AGGR_TYPE (TREE_TYPE (exprtype)))
472 errstr = "source is not a pointer to class";
475 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
477 errstr = "source is a pointer to incomplete type";
483 /* T is a reference type, v shall be an lvalue of a complete class
484 type, and the result is an lvalue of the type referred to by T. */
486 if (! IS_AGGR_TYPE (TREE_TYPE (exprtype)))
488 errstr = "source is not of class type";
491 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
493 errstr = "source is of incomplete class type";
499 /* The dynamic_cast operator shall not cast away constness. */
500 if (!at_least_as_qualified_p (TREE_TYPE (type),
501 TREE_TYPE (exprtype)))
503 errstr = "conversion casts away constness";
507 /* If *type is an unambiguous accessible base class of *exprtype,
508 convert statically. */
513 distance = get_base_distance (TREE_TYPE (type), TREE_TYPE (exprtype), 1,
518 cp_error ("dynamic_cast from `%T' to ambiguous base class `%T'",
519 TREE_TYPE (exprtype), TREE_TYPE (type));
520 return error_mark_node;
524 cp_error ("dynamic_cast from `%T' to private base class `%T'",
525 TREE_TYPE (exprtype), TREE_TYPE (type));
526 return error_mark_node;
531 expr = build_vbase_path (PLUS_EXPR, type, expr, path, 0);
532 if (TREE_CODE (exprtype) == POINTER_TYPE)
533 expr = non_lvalue (expr);
538 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
539 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype)))
542 /* if TYPE is `void *', return pointer to complete object. */
543 if (tc == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (type)))
545 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
546 if (TREE_CODE (expr) == ADDR_EXPR
547 && TREE_CODE (TREE_OPERAND (expr, 0)) == VAR_DECL
548 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == RECORD_TYPE)
549 return build1 (NOP_EXPR, type, expr);
551 /* Since expr is used twice below, save it. */
552 expr = save_expr (expr);
554 expr1 = build_headof (expr);
555 if (TREE_TYPE (expr1) != type)
556 expr1 = build1 (NOP_EXPR, type, expr1);
557 return ifnonnull (expr, expr1);
562 tree result, td2, td3, elems;
563 tree static_type, target_type, boff;
565 /* If we got here, we can't convert statically. Therefore,
566 dynamic_cast<D&>(b) (b an object) cannot succeed. */
567 if (tc == REFERENCE_TYPE)
569 if (TREE_CODE (old_expr) == VAR_DECL
570 && TREE_CODE (TREE_TYPE (old_expr)) == RECORD_TYPE)
572 tree expr = throw_bad_cast ();
573 cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
575 /* Bash it to the expected type. */
576 TREE_TYPE (expr) = type;
580 /* Ditto for dynamic_cast<D*>(&b). */
581 else if (TREE_CODE (expr) == ADDR_EXPR)
583 tree op = TREE_OPERAND (expr, 0);
584 if (TREE_CODE (op) == VAR_DECL
585 && TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE)
587 cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
589 retval = build_int_2 (0, 0);
590 TREE_TYPE (retval) = type;
595 target_type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
596 static_type = TYPE_MAIN_VARIANT (TREE_TYPE (exprtype));
597 td2 = build_unary_op (ADDR_EXPR, get_tinfo_decl (target_type), 0);
598 td3 = build_unary_op (ADDR_EXPR, get_tinfo_decl (static_type), 0);
600 /* Determine how T and V are related. */
601 boff = get_dynamic_cast_base_type (static_type, target_type);
603 /* Since expr is used twice below, save it. */
604 expr = save_expr (expr);
607 if (tc == REFERENCE_TYPE)
608 expr1 = build_unary_op (ADDR_EXPR, expr1, 0);
611 (NULL_TREE, expr1, tree_cons
612 (NULL_TREE, td3, tree_cons
613 (NULL_TREE, td2, tree_cons
614 (NULL_TREE, boff, NULL_TREE))));
616 dcast_fn = dynamic_cast_node;
624 push_nested_namespace (ns);
625 tinfo_ptr = xref_tag (class_type_node,
626 get_identifier ("__class_type_info"),
629 tinfo_ptr = build_pointer_type
630 (build_qualified_type
631 (tinfo_ptr, TYPE_QUAL_CONST));
632 name = "__dynamic_cast";
634 (NULL_TREE, const_ptr_type_node, tree_cons
635 (NULL_TREE, tinfo_ptr, tree_cons
636 (NULL_TREE, tinfo_ptr, tree_cons
637 (NULL_TREE, ptrdiff_type_node, void_list_node))));
638 tmp = build_function_type (ptr_type_node, tmp);
639 dcast_fn = build_library_fn_ptr (name, tmp);
640 pop_nested_namespace (ns);
641 dynamic_cast_node = dcast_fn;
643 result = build_call (dcast_fn, elems);
645 if (tc == REFERENCE_TYPE)
647 tree bad = throw_bad_cast ();
649 result = save_expr (result);
650 return build (COND_EXPR, type, result, result, bad);
653 /* Now back to the type we want from a void*. */
654 result = cp_convert (type, result);
655 return ifnonnull (expr, result);
659 errstr = "source type is not polymorphic";
662 cp_error ("cannot dynamic_cast `%E' (of type `%#T') to type `%#T' (%s)",
663 expr, exprtype, type, errstr);
664 return error_mark_node;
668 build_dynamic_cast (type, expr)
671 if (type == error_mark_node || expr == error_mark_node)
672 return error_mark_node;
674 if (processing_template_decl)
675 return build_min (DYNAMIC_CAST_EXPR, type, expr);
677 return convert_from_reference (build_dynamic_cast_1 (type, expr));
680 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
683 qualifier_flags (type)
687 /* we want the qualifiers on this type, not any array core, it might have */
688 int quals = TYPE_QUALS (type);
690 if (quals & TYPE_QUAL_CONST)
692 if (quals & TYPE_QUAL_VOLATILE)
694 if (quals & TYPE_QUAL_RESTRICT)
699 /* Return non-zero, if the pointer chain TYPE ends at an incomplete type, or
700 contains a pointer to member of an incomplete class. */
703 target_incomplete_p (type)
706 while (TREE_CODE (type) == POINTER_TYPE)
707 if (TYPE_PTRMEM_P (type))
709 if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type)))
711 type = TYPE_PTRMEM_POINTED_TO_TYPE (type);
714 type = TREE_TYPE (type);
715 if (!COMPLETE_OR_VOID_TYPE_P (type))
721 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
722 is the vtable pointer and NTBS name. The NTBS name is emitted as a
723 comdat const char array, so it becomes a unique key for the type. Generate
724 and emit that VAR_DECL here. (We can't always emit the type_info itself
725 as comdat, because of pointers to incomplete.) */
728 tinfo_base_init (desc, target)
732 tree init = NULL_TREE;
738 /* Generate the NTBS array variable. */
739 tree name_type = build_cplus_array_type
740 (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
742 tree name_string = tinfo_name (target);
744 name_name = mangle_typeinfo_string_for_type (target);
745 name_decl = build_lang_decl (VAR_DECL, name_name, name_type);
747 DECL_ARTIFICIAL (name_decl) = 1;
748 TREE_READONLY (name_decl) = 1;
749 TREE_STATIC (name_decl) = 1;
750 DECL_EXTERNAL (name_decl) = 0;
751 TREE_PUBLIC (name_decl) = 1;
752 comdat_linkage (name_decl);
753 /* External name of the string containing the type's name has a
755 SET_DECL_ASSEMBLER_NAME (name_decl,
756 mangle_typeinfo_string_for_type (target));
757 DECL_INITIAL (name_decl) = name_string;
758 cp_finish_decl (name_decl, name_string, NULL_TREE, 0);
759 pushdecl_top_level (name_decl);
762 if (TINFO_VTABLE_DECL (desc))
764 tree vtbl_ptr = TINFO_VTABLE_DECL (desc);
765 init = tree_cons (NULL_TREE, vtbl_ptr, init);
768 init = tree_cons (NULL_TREE, decay_conversion (name_decl), init);
770 init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, nreverse (init));
771 TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
772 init = tree_cons (NULL_TREE, init, NULL_TREE);
777 /* Return the CONSTRUCTOR expr for a type_info of TYPE. DESC provides the
778 information about the particular type_info derivation, which adds no
779 additional fields to the type_info base. */
782 generic_initializer (desc, target)
786 tree init = tinfo_base_init (desc, target);
788 init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, init);
789 TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
793 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
794 DESC provides information about the particular type_info derivation,
795 which adds target type and qualifier flags members to the type_info base. */
798 ptr_initializer (desc, target, non_public_ptr)
803 tree init = tinfo_base_init (desc, target);
804 tree to = TREE_TYPE (target);
805 int flags = qualifier_flags (to);
806 int incomplete = target_incomplete_p (to);
813 init = tree_cons (NULL_TREE, build_int_2 (flags, 0), init);
814 init = tree_cons (NULL_TREE,
815 build_unary_op (ADDR_EXPR,
816 get_tinfo_decl (TYPE_MAIN_VARIANT (to)), 0),
819 init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, nreverse (init));
820 TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
824 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
825 DESC provides information about the particular type_info derivation,
826 which adds class, target type and qualifier flags members to the type_info
830 ptm_initializer (desc, target, non_public_ptr)
835 tree init = tinfo_base_init (desc, target);
836 tree to = TYPE_PTRMEM_POINTED_TO_TYPE (target);
837 tree klass = TYPE_PTRMEM_CLASS_TYPE (target);
838 int flags = qualifier_flags (to);
839 int incomplete = target_incomplete_p (to);
846 if (!COMPLETE_TYPE_P (klass))
851 init = tree_cons (NULL_TREE, build_int_2 (flags, 0), init);
852 init = tree_cons (NULL_TREE,
853 build_unary_op (ADDR_EXPR,
854 get_tinfo_decl (TYPE_MAIN_VARIANT (to)), 0),
856 init = tree_cons (NULL_TREE,
857 build_unary_op (ADDR_EXPR, get_tinfo_decl (klass), 0),
860 init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, nreverse (init));
861 TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
865 /* Check base BINFO to set hint flags in *DATA, which is really an int.
866 We use CLASSTYPE_MARKED to tag types we've found as non-virtual bases and
867 CLASSTYPE_MARKED2 to tag those which are virtual bases. Remember it is
868 possible for a type to be both a virtual and non-virtual base. */
871 dfs_class_hint_mark (binfo, data)
875 tree basetype = BINFO_TYPE (binfo);
876 int *hint = (int *) data;
878 if (TREE_VIA_VIRTUAL (binfo))
880 if (CLASSTYPE_MARKED (basetype))
882 if (CLASSTYPE_MARKED2 (basetype))
884 SET_CLASSTYPE_MARKED2 (basetype);
888 if (CLASSTYPE_MARKED (basetype) || CLASSTYPE_MARKED2 (basetype))
890 SET_CLASSTYPE_MARKED (basetype);
892 if (!TREE_VIA_PUBLIC (binfo) && TYPE_BINFO (basetype) != binfo)
897 /* Clear the base's dfs marks, after searching for duplicate bases. */
900 dfs_class_hint_unmark (binfo, data)
902 void *data ATTRIBUTE_UNUSED;
904 tree basetype = BINFO_TYPE (binfo);
906 CLEAR_CLASSTYPE_MARKED (basetype);
907 CLEAR_CLASSTYPE_MARKED2 (basetype);
911 /* Determine the hint flags describing the features of a class's heirarchy. */
914 class_hint_flags (type)
920 dfs_walk (TYPE_BINFO (type), dfs_class_hint_mark, NULL, &hint_flags);
921 dfs_walk (TYPE_BINFO (type), dfs_class_hint_unmark, NULL, NULL);
923 for (i = 0; i < CLASSTYPE_N_BASECLASSES (type); ++i)
925 tree base_binfo = BINFO_BASETYPE (TYPE_BINFO (type), i);
927 if (TREE_VIA_PUBLIC (base_binfo))
933 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
934 DESC provides information about the particular __class_type_info derivation,
935 which adds hint flags and TRAIL initializers to the type_info base. */
938 class_initializer (desc, target, trail)
943 tree init = tinfo_base_init (desc, target);
945 TREE_CHAIN (init) = trail;
946 init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, init);
947 TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
951 /* Returns non-zero if the typeinfo for type should be placed in
952 the runtime library. */
955 typeinfo_in_lib_p (type)
958 /* The typeinfo objects for `T*' and `const T*' are in the runtime
959 library for simple types T. */
960 if (TREE_CODE (type) == POINTER_TYPE
961 && (CP_TYPE_QUALS (TREE_TYPE (type)) == TYPE_QUAL_CONST
962 || CP_TYPE_QUALS (TREE_TYPE (type)) == TYPE_UNQUALIFIED))
963 type = TREE_TYPE (type);
965 switch (TREE_CODE (type))
979 /* Generate a pseudo_type_info VAR_DECL suitable for the supplied
980 TARGET_TYPE and given the REAL_NAME. This is the structure expected by
981 the runtime, and therefore has additional fields. If we need not emit a
982 definition (because the runtime must contain it), return NULL_TREE,
983 otherwise return the VAR_DECL. */
986 synthesize_tinfo_var (target_type, real_name)
990 tree var_init = NULL_TREE;
991 tree var_type = NULL_TREE;
994 switch (TREE_CODE (target_type))
997 if (TYPE_PTRMEM_P (target_type))
999 var_type = ptm_desc_type_node;
1000 var_init = ptm_initializer (var_type, target_type, &non_public);
1004 if (typeinfo_in_lib_p (target_type) && !doing_runtime)
1005 /* These are in the runtime. */
1007 var_type = ptr_desc_type_node;
1008 var_init = ptr_initializer (var_type, target_type, &non_public);
1012 var_type = enum_desc_type_node;
1013 var_init = generic_initializer (var_type, target_type);
1016 var_type = func_desc_type_node;
1017 var_init = generic_initializer (var_type, target_type);
1020 var_type = ary_desc_type_node;
1021 var_init = generic_initializer (var_type, target_type);
1025 if (TYPE_PTRMEMFUNC_P (target_type))
1027 var_type = ptm_desc_type_node;
1028 var_init = ptm_initializer (var_type, target_type, &non_public);
1030 else if (!COMPLETE_TYPE_P (target_type))
1032 /* Emit a non-public class_type_info. */
1034 var_type = class_desc_type_node;
1035 var_init = class_initializer (var_type, target_type, NULL_TREE);
1037 else if (!CLASSTYPE_N_BASECLASSES (target_type))
1039 var_type = class_desc_type_node;
1040 var_init = class_initializer (var_type, target_type, NULL_TREE);
1044 /* if this has a single public non-virtual base, it's easier */
1045 tree binfo = TYPE_BINFO (target_type);
1046 int nbases = BINFO_N_BASETYPES (binfo);
1047 tree base_binfos = BINFO_BASETYPES (binfo);
1048 tree base_inits = NULL_TREE;
1049 int is_simple = nbases == 1;
1052 /* Generate the base information initializer. */
1053 for (ix = nbases; ix--;)
1055 tree base_binfo = TREE_VEC_ELT (base_binfos, ix);
1056 tree base_init = NULL_TREE;
1061 if (TREE_PUBLIC (base_binfo))
1063 tinfo = get_tinfo_decl (BINFO_TYPE (base_binfo));
1064 tinfo = build_unary_op (ADDR_EXPR, tinfo, 0);
1065 if (TREE_VIA_VIRTUAL (base_binfo))
1067 /* We store the vtable offset at which the virtual
1068 base offset can be found. */
1069 offset = BINFO_VPTR_FIELD (binfo_for_vbase (BINFO_TYPE (base_binfo),
1071 offset = convert (sizetype, offset);
1075 offset = BINFO_OFFSET (base_binfo);
1077 /* is it a single public inheritance? */
1078 if (is_simple && flags == 2 && integer_zerop (offset))
1080 base_inits = tree_cons (NULL_TREE, tinfo, NULL_TREE);
1085 /* combine offset and flags into one field */
1086 offset = cp_build_binary_op (LSHIFT_EXPR, offset,
1087 build_int_2 (8, 0));
1088 offset = cp_build_binary_op (BIT_IOR_EXPR, offset,
1089 build_int_2 (flags, 0));
1090 base_init = tree_cons (NULL_TREE, offset, base_init);
1091 base_init = tree_cons (NULL_TREE, tinfo, base_init);
1092 base_init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, base_init);
1093 base_inits = tree_cons (NULL_TREE, base_init, base_inits);
1097 var_type = si_class_desc_type_node;
1100 int hint = class_hint_flags (target_type);
1102 base_inits = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, base_inits);
1103 base_inits = tree_cons (NULL_TREE, base_inits, NULL_TREE);
1104 /* Prepend the number of bases. */
1105 base_inits = tree_cons (NULL_TREE,
1106 build_int_2 (nbases, 0), base_inits);
1107 /* Prepend the hint flags. */
1108 base_inits = tree_cons (NULL_TREE,
1109 build_int_2 (hint, 0), base_inits);
1110 var_type = get_vmi_pseudo_type_info (nbases);
1112 var_init = class_initializer (var_type, target_type, base_inits);
1117 if (typeinfo_in_lib_p (target_type))
1120 /* These are guaranteed to be in the runtime. */
1122 var_type = bltn_desc_type_node;
1123 var_init = generic_initializer (var_type, target_type);
1126 my_friendly_abort (20000117);
1129 return create_real_tinfo_var (target_type,
1130 real_name, TINFO_PSEUDO_TYPE (var_type),
1131 var_init, non_public);
1134 /* Create the real typeinfo variable. NON_PUBLIC indicates that we cannot
1135 make this variable public (comdat). */
1138 create_real_tinfo_var (target_type, name, type, init, non_public)
1145 static int count = 0;
1150 sprintf (hidden, "__ti_%d", count++);
1151 hidden_name = get_identifier (hidden);
1153 decl = build_lang_decl (VAR_DECL, hidden_name,
1154 build_qualified_type (type, TYPE_QUAL_CONST));
1155 DECL_ARTIFICIAL (decl) = 1;
1156 TREE_READONLY (decl) = 1;
1157 TREE_STATIC (decl) = 1;
1158 DECL_EXTERNAL (decl) = 0;
1162 TREE_PUBLIC (decl) = 1;
1163 if (flag_weak || !typeinfo_in_lib_p (target_type))
1164 comdat_linkage (decl);
1166 SET_DECL_ASSEMBLER_NAME (decl, name);
1167 DECL_INITIAL (decl) = init;
1168 cp_finish_decl (decl, init, NULL_TREE, 0);
1169 pushdecl_top_level (decl);
1170 TREE_USED (decl) = 1;
1174 /* Generate the RECORD_TYPE containing the data layout of a type_info
1175 derivative as used by the runtime. This layout must be consistent with
1176 that defined in the runtime support. Also generate the VAR_DECL for the
1177 type's vtable. We explicitly manage the vtable member, and name it for
1178 real type as used in the runtime. The RECORD type has a different name,
1179 to avoid collisions. Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1180 is the generated type and TINFO_VTABLE_DECL is the vtable decl.
1182 REAL_NAME is the runtime's name of the type. Trailing arguments are
1183 additional FIELD_DECL's for the structure. The final argument must be
1187 create_pseudo_type_info VPARAMS((const char *real_name, int ident, ...))
1189 #ifndef ANSI_PROTOTYPES
1190 char const *real_name;
1194 tree real_type, pseudo_type;
1202 VA_START (ap, ident);
1203 #ifndef ANSI_PROTOTYPES
1204 real_name = va_arg (ap, char const *);
1205 ident = va_arg (app, int);
1208 /* Generate the pseudo type name. */
1209 pseudo_name = (char *)alloca (strlen (real_name) + 30);
1210 strcpy (pseudo_name, real_name);
1211 strcat (pseudo_name, "_pseudo");
1213 sprintf (pseudo_name + strlen (pseudo_name), "%d", ident);
1215 /* Get the vtable decl. */
1216 real_type = xref_tag (class_type_node, get_identifier (real_name), 1);
1217 vtable_decl = get_vtable_decl (real_type, /*complete=*/1);
1218 vtable_decl = build_unary_op (ADDR_EXPR, vtable_decl, 0);
1220 /* We need to point into the middle of the vtable. */
1221 vtable_decl = build (PLUS_EXPR,
1222 TREE_TYPE (vtable_decl),
1224 size_binop (MULT_EXPR,
1226 TYPE_SIZE_UNIT (vtable_entry_type)));
1227 TREE_CONSTANT (vtable_decl) = 1;
1229 /* First field is the pseudo type_info base class. */
1230 fields[0] = build_decl (FIELD_DECL, NULL_TREE, ti_desc_type_node);
1232 /* Now add the derived fields. */
1233 for (ix = 0; (field_decl = va_arg (ap, tree));)
1234 fields[++ix] = field_decl;
1236 /* Create the pseudo type. */
1237 pseudo_type = make_aggr_type (RECORD_TYPE);
1238 finish_builtin_type (pseudo_type, pseudo_name, fields, ix, ptr_type_node);
1239 TYPE_HAS_CONSTRUCTOR (pseudo_type) = 1;
1242 result = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE);
1243 TINFO_VTABLE_DECL (result) = vtable_decl;
1244 TINFO_PSEUDO_TYPE (result) = pseudo_type;
1249 /* Return a descriptor for a vmi type with NUM_BASES bases. */
1252 get_vmi_pseudo_type_info (num_bases)
1256 tree array_domain, base_array;
1258 if (TREE_VEC_LENGTH (vmi_class_desc_type_node) <= num_bases)
1261 tree extend = make_tree_vec (num_bases + 5);
1263 for (ix = TREE_VEC_LENGTH (vmi_class_desc_type_node); ix--;)
1264 TREE_VEC_ELT (extend, ix) = TREE_VEC_ELT (vmi_class_desc_type_node, ix);
1265 vmi_class_desc_type_node = extend;
1267 desc = TREE_VEC_ELT (vmi_class_desc_type_node, num_bases);
1272 /* Add number of bases and trailing array of base_class_type_info. */
1273 array_domain = build_index_type (size_int (num_bases));
1274 base_array = build_array_type (base_desc_type_node, array_domain);
1276 push_nested_namespace (abi_node);
1278 desc = create_pseudo_type_info
1279 ("__vmi_class_type_info", num_bases,
1280 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1281 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1282 build_decl (FIELD_DECL, NULL_TREE, base_array),
1285 pop_nested_namespace (abi_node);
1287 TREE_VEC_ELT (vmi_class_desc_type_node, num_bases) = desc;
1291 /* Make sure the required builtin types exist for generating the type_info
1292 varable definitions. */
1295 create_tinfo_types ()
1299 if (bltn_desc_type_node)
1301 push_nested_namespace (abi_node);
1303 ptr_type_info = build_pointer_type
1304 (build_qualified_type
1305 (type_info_type_node, TYPE_QUAL_CONST));
1307 /* Create the internal type_info structure. This is used as a base for
1308 the other structures. */
1312 ti_desc_type_node = make_aggr_type (RECORD_TYPE);
1313 fields[0] = build_decl (FIELD_DECL, NULL_TREE, const_ptr_type_node);
1314 fields[1] = build_decl (FIELD_DECL, NULL_TREE, const_string_type_node);
1315 finish_builtin_type (ti_desc_type_node, "__type_info_pseudo",
1316 fields, 1, ptr_type_node);
1317 TYPE_HAS_CONSTRUCTOR (ti_desc_type_node) = 1;
1320 /* Fundamental type_info */
1321 bltn_desc_type_node = create_pseudo_type_info
1322 ("__fundamental_type_info", 0,
1325 /* Array, function and enum type_info. No additional fields. */
1326 ary_desc_type_node = create_pseudo_type_info
1327 ("__array_type_info", 0,
1329 func_desc_type_node = create_pseudo_type_info
1330 ("__function_type_info", 0,
1332 enum_desc_type_node = create_pseudo_type_info
1333 ("__enum_type_info", 0,
1336 /* Class type_info. Add a flags field. */
1337 class_desc_type_node = create_pseudo_type_info
1338 ("__class_type_info", 0,
1341 /* Single public non-virtual base class. Add pointer to base class.
1342 This is really a descendant of __class_type_info. */
1343 si_class_desc_type_node = create_pseudo_type_info
1344 ("__si_class_type_info", 0,
1345 build_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
1348 /* Base class internal helper. Pointer to base type, offset to base,
1353 fields[0] = build_decl (FIELD_DECL, NULL_TREE, ptr_type_info);
1354 fields[1] = build_decl (FIELD_DECL, NULL_TREE, integer_types[itk_long]);
1355 base_desc_type_node = make_aggr_type (RECORD_TYPE);
1356 finish_builtin_type (base_desc_type_node, "__base_class_type_info_pseudo",
1357 fields, 1, ptr_type_node);
1358 TYPE_HAS_CONSTRUCTOR (base_desc_type_node) = 1;
1361 /* General heirarchy is created as necessary in this vector. */
1362 vmi_class_desc_type_node = make_tree_vec (10);
1364 /* Pointer type_info. Adds two fields, qualification mask
1365 and pointer to the pointed to type. This is really a descendant of
1366 __pbase_type_info. */
1367 ptr_desc_type_node = create_pseudo_type_info
1368 ("__pointer_type_info", 0,
1369 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1370 build_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
1373 /* Pointer to member data type_info. Add qualifications flags,
1374 pointer to the member's type info and pointer to the class.
1375 This is really a descendant of __pbase_type_info. */
1376 ptm_desc_type_node = create_pseudo_type_info
1377 ("__pointer_to_member_type_info", 0,
1378 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1379 build_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
1380 build_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
1383 pop_nested_namespace (abi_node);
1386 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1387 support. Generating them here guarantees consistency with the other
1388 structures. We use the following heuristic to determine when the runtime
1389 is being generated. If std::__fundamental_type_info is defined, and its
1390 destructor is defined, then the runtime is being built. */
1393 emit_support_tinfos ()
1395 static tree *const fundamentals[] =
1400 &char_type_node, &signed_char_type_node, &unsigned_char_type_node,
1401 &short_integer_type_node, &short_unsigned_type_node,
1402 &integer_type_node, &unsigned_type_node,
1403 &long_integer_type_node, &long_unsigned_type_node,
1404 &long_long_integer_type_node, &long_long_unsigned_type_node,
1405 &float_type_node, &double_type_node, &long_double_type_node,
1409 tree bltn_type, dtor;
1411 push_nested_namespace (abi_node);
1412 bltn_type = xref_tag (class_type_node,
1413 get_identifier ("__fundamental_type_info"), 1);
1414 pop_nested_namespace (abi_node);
1415 if (!COMPLETE_TYPE_P (bltn_type))
1417 dtor = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (bltn_type), 1);
1418 if (DECL_EXTERNAL (dtor))
1421 for (ix = 0; fundamentals[ix]; ix++)
1423 tree bltn = *fundamentals[ix];
1424 tree bltn_ptr = build_pointer_type (bltn);
1425 tree bltn_const_ptr = build_pointer_type
1426 (build_qualified_type (bltn, TYPE_QUAL_CONST));
1429 tinfo = get_tinfo_decl (bltn);
1430 TREE_USED (tinfo) = 1;
1431 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo)) = 1;
1433 tinfo = get_tinfo_decl (bltn_ptr);
1434 TREE_USED (tinfo) = 1;
1435 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo)) = 1;
1437 tinfo = get_tinfo_decl (bltn_const_ptr);
1438 TREE_USED (tinfo) = 1;
1439 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo)) = 1;
1443 /* Return non-zero, iff T is a type_info variable which has not had a
1444 definition emitted for it. */
1447 tinfo_decl_p (t, data)
1449 void *data ATTRIBUTE_UNUSED;
1451 return TREE_CODE (t) == VAR_DECL
1452 && IDENTIFIER_GLOBAL_VALUE (DECL_NAME (t)) == (t)
1453 && TREE_TYPE (t) == tinfo_decl_type
1454 && TREE_TYPE (DECL_NAME (t));
1457 /* Emit a suitable type_info definition for the type_info decl pointed to by
1458 DECL_PTR. We emit a completely new variable, of the correct type for the
1459 actual type this is describing. The DECL_ASSEMBLER_NAME of the generated
1460 definition is set to that of the supplied decl, so that they can be tied
1461 up. Mark the supplied decl as having been dealt with. Emitting one
1462 definition might cause other definitions to be required.
1464 We need to do things this way, because we're trying to do something like
1470 extern const A tinfo_var;
1472 const B tinfo_var = {...};
1474 which is not permitted. Also, we've not necessarily seen the definition of B.
1475 So we do something like the following,
1477 extern const A tinfo_var;
1480 const void *vtable_ptr;
1488 const pseudo_B proxy_tinfo_var attribute((assembler_name="tinfo_var")) =
1490 {&B::vtable, "..."},
1494 pseudo_A and pseudo_B must be layout equivalent to the real definitions in
1498 emit_tinfo_decl (decl_ptr, data)
1500 void *data ATTRIBUTE_UNUSED;
1502 tree tinfo_decl = *decl_ptr;
1503 tree tinfo_type, decl;
1505 my_friendly_assert (TREE_TYPE (tinfo_decl) == tinfo_decl_type, 20000121);
1506 tinfo_type = TREE_TYPE (DECL_NAME (tinfo_decl));
1507 my_friendly_assert (tinfo_type != NULL_TREE, 20000120);
1509 if (!DECL_NEEDED_P (tinfo_decl))
1511 /* Say we've dealt with it. */
1512 TREE_TYPE (DECL_NAME (tinfo_decl)) = NULL_TREE;
1514 create_tinfo_types ();
1515 decl = synthesize_tinfo_var (tinfo_type, DECL_ASSEMBLER_NAME (tinfo_decl));